nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
paradiseo/contribution/branches/PSO-DVRP/eoPsoDVRPutils.cpp

1789 lines
34 KiB
C++
Raw Blame History

/*
* Copyright (C) DOLPHIN Project-Team, INRIA Lille Nord-Europe, 2007-2008
* (C) OPAC Team, LIFL, 2002-2008
*
* (c) Mostepha Redouane Khouadjia <mr.khouadjia@ed.univ-lille1.fr>, 2008
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
#include "eoPsoDVRPutils.h"
// The computed distances will be stored in dist.
setCustumers clients;
std::vector<unsigned> newCustomers;
lengthMatrix dist;
template<typename T>
std::string to_string( const T & Value )
{
// utiliser un flux de sortie pour créer la chaîne
std::ostringstream oss;
// écrire la valeur dans le flux
oss << Value;
// renvoyer une string
return oss.str();
}
void computeDistances() {
dist.resize (clients.size ()) ;
for (unsigned i = 0; i < dist.size (); i ++)
dist [i].resize (clients.size ());
// Distances computation
for (unsigned i = 0; i < dist.size (); i ++)
for (unsigned j = i ; j < dist.size (); j ++)
{
double distX = clients [i].x - clients [j].x;
double distY = clients [i].y - clients [j].y;
dist [i][j] = dist [j][i] = sqrt (distX * distX + distY * distY);
}
}
/**
* \brief Returns the time window information of a given client.
* \param _client The client whose information we want to know.
* \param _availTime Return value. The time xhen client will be available in system.
* \param _durationService Return value. The client's service time.
*/
void getInformation (unsigned _custumer, double& _availTime, double& _durationService) {
assert (_custumer >= 0 && _custumer < clients.size ());
_availTime = clients [_custumer].availTime;
_durationService = clients [_custumer].durationService;
}
/**
* \brief A function to get the distance between two clients.
* \param _from The first client.
* \param _to The second client.
* \return The distance between _from and _to.
*/
void PrintCustumersMatrix (){
for (int i =0 ; i < clients.size(); ++i)
cout<< clients[i].id<<'\t'<<clients[i].x<<'\t'<<clients[i].y<<'\t'<<clients[i].demand<<'\t'<<clients[i].durationService<<endl;
}
double distance (const lengthMatrix _dist, unsigned _from, unsigned _to) {
assert (_from >= 0 && _from < clients.size ());
assert (_to >= 0 && _to < clients.size ());
return _dist [_from][_to];
}
const lengthMatrix distanceMatrix() {return dist;}
/**
* \brief Loads the problem data from a given file.
* \param _fileName The file to load data from.
* \warning No error check is performed!
*/
double computTourLength(Route _route)
{
double RouteLength =0.0;
for (unsigned i = 0, size = _route.size()-1; i < size; ++i )
RouteLength+=distance(dist,_route[i], _route[i+1]);
RouteLength+= distance(dist, _route.back(),0);
return RouteLength;
}
double computTourLength( Routes _mRoute)
{
double MatrixLength =0.0;
for(unsigned tr = 0, tsize = _mRoute.size(); tr < tsize; ++tr )
MatrixLength += computTourLength(_mRoute[tr]);
return MatrixLength;
}
bool findClient (unsigned id) // Look for one customers in the table Clients
{
for ( size_t i = 0, size = clients.size(); i < size; ++i )
{
if (id == (clients.at(i)).id)
return true;
}
return false;
}
void loadNewCustomers(double _timeStep, double _timeSlice){
unsigned id_customer;
newCustomers.clear();
unsigned i = 1;
while (i < clients.size())
{
if(clients[i].availTime > (_timeStep - _timeSlice) && clients[i].availTime <=_timeStep)
newCustomers.push_back(clients[i].id);
i++;
}
}
void loadMatrixCustomers (const string _fileName) {
string line;
istringstream iss;
std::ifstream file (_fileName.c_str());
ClientDataT depot, custumer;
unsigned int id;
if (file) {
depot.id= 0;
depot.availTime = depot.demand=depot.durationService = 0.0;
clients.push_back (depot);
do
getline(file,line);
while (line.find("DEMAND_SECTION")== string::npos);
getline(file,line);
do{
iss.str(line);
iss>> custumer.id>>custumer.demand;
clients.push_back (custumer);
iss.clear();
getline(file,line);
}while(line.find("LOCATION_COORD_SECTION")== string::npos);
getline(file,line);
do{
iss.str(line);
iss>>id;
iss>>clients[id].x;
iss>>clients[id].y;
iss.clear();
getline(file,line);
} while(line.find("DEPOT_LOCATION_SECTION")== string::npos);
do
getline(file,line);
while (line.find("DURATION_SECTION")== string::npos);
getline(file,line);
do{ iss.str(line);
iss>>id;
iss>>clients[id].durationService;
iss.clear();
getline(file,line);
} while(line.find("DEPOT_TIME_WINDOW_SECTION")== string::npos);
getline(file,line);
iss.str(line);
iss>>id;
iss>>clients[id].availTime>>clients[id].durationService;
iss.clear();
do
getline(file,line);
while(line.find("TIME_AVAIL_SECTION")== string::npos);
getline(file,line);
do{
iss.str(line);
iss>>id;
iss>>clients[id].availTime;
iss.clear();
getline(file,line);
} while(line.find("EOF")== string::npos);
file.close ();
computeDistances();
}
else {
std::cerr << "Error: the file: " << _fileName << " doesn't exist !!!" << std::endl ;
abort();
}
}
/**
* \brief Prints a route to the standard output.
* \param _route The route to print.
*/
void printRoute (const Route& _route, std::ostream &_os) {
_os<< "[";
for (unsigned i = 0; i < _route.size (); i++) {
_os << _route [i];
if (i != _route.size () -1)
_os << ", ";
}
_os << "]"<<endl;
}
/**
* \brief Prints a set of routes to the standard output.
* \param _routes The set of routes to print.
*/
void printRoutes (const Routes& _routes, std::ostream &_os) {
for (unsigned i = 0; i < _routes.size (); i++)
{_os <<i+1<<'\t';
printRoute ( _routes [i],_os);
}
}
double getTimeOfService (Route _route, double _startTime, unsigned _newCustomer_id, unsigned _newPosition)
{
double duration = _startTime;
if( _route.empty())
cerr<< "You want to get the time of service from empty tour....!!!!"<<endl;
_route.insert (_route.begin() + _newPosition, _newCustomer_id ) ;
for (size_t i = 0 ; i < _route.size()-1 ; ++ i )
duration += distance(dist,_route[i], _route[i+1]);
for (size_t i = 1 ; i < _route.size() ; ++ i ) //depot
duration += clients[_route[i]].durationService;
return duration;
}
double getTimeOfService(Route _route, unsigned _lastServedCustomer_id, double _serviceTime, unsigned _newCustomer_id, unsigned _newPosition)
{
double nextTimeStep = TIME_STEP; //
double dispo = _serviceTime + clients[_lastServedCustomer_id].durationService;
double duration = startServiceTime( nextTimeStep , dispo );
_route.insert(_route.begin() + _newPosition, _newCustomer_id);
unsigned index = 1 ;
while (_route[index] != _lastServedCustomer_id) index ++ ;
for (unsigned i = index; i < _route.size() - 1 ; ++ i )
duration+= distance(dist,_route[i], _route[i+1]);
for (unsigned i = index + 1 ; i < _route.size() ; ++ i )
duration+= clients[_route[i]].durationService ;
return duration ;
}
double getTimeOfService(const Route _route, unsigned _lastServedCustomer_id, double dispo)
{
double nextTimeStep = TIME_STEP ;
double duration = startServiceTime( nextTimeStep , dispo );
unsigned index = 1 ;
while (_route[index] != _lastServedCustomer_id) index ++ ;
for (unsigned i = index; i < _route.size() - 1 ; ++ i )
duration+= distance(dist,_route[i], _route[i+1]);
for (unsigned i = index + 1 ; i < _route.size() ; ++ i )
duration+= clients[_route[i]].durationService ;
return duration ;
}
double startServiceTime (double _nextTimeStep, double _dispoTime)
{
if (_nextTimeStep > _dispoTime)
return _nextTimeStep ;
else
return _dispoTime;
}
double getCapacityUsed (Route _route)
{
double charge =0.0;
unsigned id_custumer;
for (size_t i=1, size = _route.size(); i <size ; ++i )
{
id_custumer =_route[i];
charge+= clients [id_custumer].demand;
}
return charge;
}
void PrintCustumers() {
for ( size_t i = 0, size = clients.size(); i < size; ++i )
std::cout<< clients[i].id <<'\t'
<<clients[i].availTime<<'\t'
<<clients[i].demand<<'\t'
<<clients[i].x<<'\t'
<<clients[i].y<<'\t'
<<clients[i].durationService <<endl;
for ( size_t i = 0, size = dist.size(); i < size; ++i )
{
std::cout<<endl;
for(size_t j = 0, size = dist.size(); j < size; ++j )
std::cout<< dist[i][j]<<'\t';
}
}
void PrintLastCustomers(){
std::cout<<"The last customers :"<<newCustomers.size()<<endl;
for ( size_t i = 0, size = newCustomers.size(); i < size; ++i )
std::cout<<newCustomers[i]<<'\t';
}
const setCustumers SetKnowClients(){
return clients;
}
Route emptyRoute (){
Route newRoute;
newRoute.push_back(0);
return newRoute;
}
unsigned randTour(unsigned maxTour)
{
eoUniformGenerator<unsigned int > uGen(0,maxTour);
return uGen();
}
int randVelocity(int sizetr)
{
eoUniformGenerator<int > uGen(-sizetr,sizetr);
return uGen();
}
unsigned randPosition (unsigned _lastPosition, unsigned _sizeTour)
{
eoUniformGenerator<unsigned> uGen(_lastPosition ,_sizeTour);
return uGen();
}
void checkDistances(const Routes _matrix)
{
double longeurTotal = 0.0 ;
for(size_t tr = 0, tsize =_matrix.size(); tr < tsize; ++tr )
{
double longeur = 0.0 ;
for (size_t i = 0, size = _matrix[tr].size()-1; i < size; ++i )
longeur +=distance(dist,_matrix[tr][i], _matrix[tr][i+1]);
cout << endl<<"distance route "<< tr+1 << " "<< longeur <<endl ;
longeurTotal += longeur;
}
cout << endl<<"distance totale "<< longeurTotal << endl ;
}
void checkCharge(const Routes _matrix)
{
for(size_t tr = 0, tsize =_matrix.size(); tr < tsize; ++tr )
{ double charge = 0.0 ;
for(size_t i = 1, size = _matrix[tr].size() ; i < size; ++i )
charge += clients [_matrix[tr][i]].demand;
cout << endl<<"charge of route "<< tr+1 << " "<< charge <<endl ;
}
}
void visualization (const Routes _matrix, unsigned _seed, std::ofstream& _os)
{
//ofstream file ("visualization.txt");
if ( !_os )
{
cerr << "Creation file failed\n";
return;
}
_os<<"Seed "<<_seed<<endl;
_os<<endl<<"#index 0"<<endl;
_os<<clients[0].x<<'\t'<< clients[0].y<<endl;
_os<<endl<<endl<<"#index 1"<<endl;
for (size_t i = 1, size = clients.size(); i < size; i++)
_os << clients[i].id<<'\t'<<clients[i].x<<'\t'<<clients[i].y<<endl;
for (size_t i =0, sizeL = _matrix.size(); i < sizeL ; i++)
{
_os<<endl<<endl<<"#index "<<i+2<<endl;
for(size_t j = 0, sizeC = _matrix[i].size(); j < sizeC ; j++)
_os << _matrix[i][j]<<'\t'<< clients[_matrix[i][j]].x<<'\t'<< clients[_matrix[i][j]].y<<endl;
}
_os <<endl<<"--********************************************************************************"<<endl;
_os.close();
}
void cheapestInsertionAlgorithm (Route _route, unsigned indexTour,
double _startTime, unsigned customer_id, unsigned & cheapestTour,double & cheapestTourCost,
unsigned & positionCheapestTour, bool & commitCustomer)
{
double costInsertion, cheapestCostInsertion, depotTimeWindow = clients[0].durationService;
unsigned positionTour, cheapestPosition;
bool feasibleInsertion = false ;
for( size_t i = 1, sizetr = _route.size()-1 ; i < sizetr; i ++)
{
if ( i < _route.size() - 1)
{
unsigned lastCustomer_id = _route [i];
unsigned nextCustomer_id = _route[i+1];
costInsertion = distance(dist,lastCustomer_id , customer_id) +
distance (dist, customer_id, nextCustomer_id) -
distance (dist, lastCustomer_id, nextCustomer_id);
}
else
costInsertion = distance (dist, _route.back(), customer_id ) +
distance (dist, customer_id, 0) -
distance (dist, _route.back(), 0);
positionTour = i+1 ;
double dueTime = getTimeOfService(_route,_startTime, customer_id, positionTour)
+ distance (dist,_route.back(),0) ;
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < cheapestCostInsertion))
{ cheapestCostInsertion = costInsertion;
cheapestPosition = positionTour;
feasibleInsertion = true;
}
}
}
if(!commitCustomer && feasibleInsertion)
{
commitCustomer = true;
cheapestTourCost = cheapestCostInsertion;
positionCheapestTour = cheapestPosition;
cheapestTour = indexTour;
}
else
{
if(feasibleInsertion)
if( cheapestCostInsertion < cheapestTourCost )
{
cheapestTourCost = cheapestCostInsertion;
positionCheapestTour = cheapestPosition;
cheapestTour = indexTour;
}
}
}
void cheapestInsertionAlgorithm (Route _route, unsigned indexTour,
unsigned lastServedCustomer_id, unsigned lastServedCustomerPosition,
double serviceTime, unsigned customer_id, unsigned & cheapestTour,
double & cheapestTourCost, unsigned & positionCheapestTour, bool & commitCustomer)
{
double costInsertion, cheapestCostInsertion, depotTimeWindow = clients[0].durationService;
unsigned positionTour, cheapestPosition;
bool feasibleInsertion = false ;
for( size_t i = lastServedCustomerPosition +1 , sizetr = _route.size() - 1 ; i < sizetr; i ++)
{
if(i < _route.size() - 1 )
{
unsigned lastCustomer_id = _route [i];
unsigned nextCustomer_id = _route[i+1];
costInsertion = distance(dist, lastCustomer_id, customer_id) +
distance (dist, customer_id, nextCustomer_id) -
distance (dist, lastCustomer_id, nextCustomer_id);
}
else
costInsertion = distance (dist, _route.back(), customer_id) + /////
distance (dist, customer_id, 0)-
distance (dist, _route.back(), 0);
positionTour = i + 1 ;
double dueTime = getTimeOfService(_route, lastServedCustomer_id, serviceTime, customer_id, positionTour)
+ distance (dist, _route.back(),0);
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < cheapestCostInsertion))
{ cheapestCostInsertion = costInsertion;
cheapestPosition = positionTour;
feasibleInsertion = true;
}
}
}
if(!commitCustomer && feasibleInsertion)
{
commitCustomer = true;
cheapestTourCost = cheapestCostInsertion;
positionCheapestTour = cheapestPosition;
cheapestTour = indexTour;
}
else
{
if(feasibleInsertion)
if( cheapestCostInsertion < cheapestTourCost )
{
cheapestTourCost = cheapestCostInsertion;
positionCheapestTour = cheapestPosition;
cheapestTour = indexTour;
}
}
}
void nearestInsertionAlgorithm (Route _route, unsigned indexTour,
double _startTime, unsigned customer_id, unsigned & nearestTour,double & nearestTourCost,
unsigned & positionNearestTour, bool & commitCustomer)
{
double costInsertion, nearestCostInsertion, nearestCheapCostInsertion , costLeftInsertion , costRightInsertion;
unsigned leftCustomer_id, rightCustomer_id, nearestPosition, positionTour;
bool feasibleInsertion = false ;
double depotTimeWindow = clients[0].durationService;
for( size_t i = 0, sizetr = _route.size() ; i < sizetr ; i ++)
{
unsigned nearestCustomer_id = _route [i];
costInsertion = distance (dist, nearestCustomer_id, customer_id);
if (((!feasibleInsertion) ) || ( costInsertion < nearestCostInsertion))
{
if( nearestCustomer_id != 0 )
{
leftCustomer_id = _route[i-1];
if(i == _route.size()-1)
rightCustomer_id = 0;
else
rightCustomer_id = _route[i+1];
costLeftInsertion = distance (dist , leftCustomer_id , customer_id) +
distance (dist, customer_id, nearestCustomer_id ) -
distance (dist, leftCustomer_id, nearestCustomer_id ) ;
costRightInsertion = distance(dist, nearestCustomer_id, customer_id) +
distance(dist, customer_id , rightCustomer_id) -
distance (dist , nearestCustomer_id , rightCustomer_id);
if (costLeftInsertion < costRightInsertion)
positionTour = i ;
else
positionTour = i + 1 ;
}
else
positionTour = i + 1 ;
double dueTime = getTimeOfService(_route, _startTime, customer_id, positionTour)
+ distance (dist,_route.back(),0) ;
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if( dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
nearestCostInsertion =costInsertion ;
nearestPosition = positionTour;
feasibleInsertion = true;
}
else
if( nearestCustomer_id !=0 )
{
if( positionTour > i)
positionTour = i;
else
positionTour = i + 1;
double dueTime = getTimeOfService(_route, _startTime, customer_id, positionTour)
+ distance (dist,_route.back(),0) ;
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if( dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
nearestCostInsertion = costInsertion ;
nearestPosition = positionTour;
feasibleInsertion = true;
}
}
}
}
if(!commitCustomer && feasibleInsertion)
{
commitCustomer = true;
nearestTourCost = nearestCostInsertion;
positionNearestTour = nearestPosition;
nearestTour = indexTour;
}
else
{
if(feasibleInsertion)
if( nearestTourCost < nearestCostInsertion )
{
nearestTourCost = nearestCostInsertion;
positionNearestTour = nearestPosition;
nearestTour = indexTour;
}
}
}
void nearestInsertionAlgorithm (Route _route, unsigned indexTour,
unsigned lastServedCustomer_id, unsigned lastServedCustomerPosition,
double serviceTime, unsigned customer_id, unsigned & nearestTour,
double & nearestTourCost, unsigned & positionNearestTour, bool & commitCustomer)
{
double costInsertion, nearestCostInsertion, nearestCheapCostInsertion , costLeftInsertion , costRightInsertion;
unsigned leftCustomer_id, rightCustomer_id, nearestPosition, positionTour;
bool feasibleInsertion = false ;
double depotTimeWindow = clients[0].durationService;
for( size_t i = lastServedCustomerPosition, sizetr = _route.size() ; i < sizetr ; i ++)
{
unsigned nearestCustomer_id = _route [i];
costInsertion = distance (dist, nearestCustomer_id, customer_id);
if (((!feasibleInsertion) ) || ( costInsertion < nearestCostInsertion))
{
if( nearestCustomer_id != lastServedCustomer_id )
{
leftCustomer_id = _route[i-1];
if(i == _route.size()-1)
rightCustomer_id = 0;
else
rightCustomer_id = _route[i+1];
costLeftInsertion = distance (dist , leftCustomer_id , customer_id) +
distance (dist, customer_id, nearestCustomer_id ) -
distance (dist, leftCustomer_id, nearestCustomer_id ) ;
costRightInsertion = distance(dist, nearestCustomer_id, customer_id) +
distance(dist, customer_id , rightCustomer_id) -
distance (dist , nearestCustomer_id , rightCustomer_id);
if (costLeftInsertion < costRightInsertion)
positionTour = i ;
else
positionTour = i + 1 ;
}
else
positionTour = i + 1 ;
double dueTime = getTimeOfService(_route, lastServedCustomer_id, serviceTime, customer_id, positionTour)
+ distance (dist, _route.back(),0);
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if( dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
nearestCostInsertion =costInsertion ;
nearestPosition = positionTour;
feasibleInsertion = true;
}
else
if( nearestCustomer_id !=lastServedCustomer_id)
{
if( positionTour > i)
positionTour = i;
else
positionTour = i + 1;
double dueTime = getTimeOfService(_route, lastServedCustomer_id, serviceTime, customer_id, positionTour)
+ distance (dist, _route.back(),0);
double demandTour = getCapacityUsed(_route) + clients[customer_id].demand;
if( dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
nearestCostInsertion = costInsertion ;
nearestPosition = positionTour;
feasibleInsertion = true;
}
}
}
}
if(!commitCustomer && feasibleInsertion)
{
commitCustomer = true;
nearestTourCost = nearestCostInsertion;
positionNearestTour = nearestPosition;
nearestTour = indexTour;
}
else
{
if(feasibleInsertion)
if(nearestTourCost < nearestCostInsertion )
{
nearestTourCost = nearestCostInsertion;
positionNearestTour = nearestPosition;
nearestTour = indexTour;
}
}
}
void generalizedInsertionTypeOneAlgorithm (Route _route, Route & _GenRoute, unsigned indexTour, double _startTime, unsigned customer_id, unsigned & generalizedTour,
unsigned & positionGeneralizedTour, double & generalizedTourCost, bool & commitCustomer)
{
double costInsertion, lowCostInsertion;
unsigned positionTour, lowPosition;
std::vector <unsigned> tempNodes;
bool feasibleInsertion = false ;
double depotTimeWindow = clients[0].durationService;
Route _tempRoute, _GenTempRoute ;
if(_route.size() >= 3)
{
for( size_t i = 1, sizetri = _route.size()-1; i < sizetri; i ++)
{
for( size_t j = i, sizetrj = _route.size()-1 ; j < sizetrj; j ++)
for( size_t k = j+1, sizetrk = _route.size(); k < sizetrk ; k++)
{
costInsertion = distance(dist,_route[i] , customer_id) + distance (dist, customer_id, _route[j]) + distance (dist, _route[i+1],_route[k]) + distance(dist,_route[j+1],_route[k+1])
-
distance (dist, _route[i],_route[i+1]) + distance (dist, _route[j], _route[j+1]) + distance(dist,_route[k],_route[k+1]);
positionTour = i+1;
_tempRoute = _route ;
tempNodes.clear() ;
tempNodes.push_back(j); tempNodes.push_back(k);
InsertionTypeOne(_tempRoute,positionTour,customer_id,tempNodes);
double dueTime = getTimeOfService(_tempRoute, 0, _startTime ) + distance (dist,_tempRoute.back() , 0);
double demandTour = getCapacityUsed(_tempRoute);
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < lowCostInsertion))
{
lowCostInsertion= costInsertion;
lowPosition = positionTour;
_GenTempRoute = _tempRoute;
feasibleInsertion = true;
}
}
}
}
}
else
{
_tempRoute = _route ;
positionTour = _tempRoute.size();
_tempRoute.push_back(customer_id);
costInsertion = distance(dist,_tempRoute.back(), customer_id) + distance(dist,customer_id, 0) - distance(dist,_tempRoute.back(),0) ;
double dueTime = getTimeOfService(_tempRoute, 0, _startTime ) + distance (dist,_tempRoute.back() , 0);
double demandTour = getCapacityUsed(_tempRoute) + clients[customer_id].demand;
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < lowCostInsertion))
{
lowCostInsertion= costInsertion;
lowPosition = positionTour;
_GenTempRoute = _tempRoute;
feasibleInsertion = true;
}
}
}
if(feasibleInsertion)
if( !commitCustomer || lowCostInsertion < generalizedTourCost )
{
generalizedTourCost = lowCostInsertion;
positionGeneralizedTour = lowPosition;
_GenRoute = _GenTempRoute;
generalizedTour = indexTour;
commitCustomer = true;
}
}
void generalizedInsertionTypeOneAlgorithm (Route _route, Route& _Genroute, unsigned indexTour, unsigned lastServedCustomer_id,
unsigned lastServedCustomerPosition, double serviceTime, unsigned customer_id, unsigned & generalizedTour,
unsigned & positionGeneralizedTour, double & generalizedTourCost, bool & commitCustomer)
{
double costInsertion, lowCostInsertion;
unsigned positionTour, lowPosition;
std::vector <unsigned> tempNodes;
bool feasibleInsertion = false ;
double depotTimeWindow = clients[0].durationService;
Route _tempRoute, _GenTempRoute;
if(_route.size() >= 3)
{
for( size_t i = lastServedCustomer_id + 1, sizetri = _route.size() -1; i < sizetri; i ++)
{
for( size_t j = i, sizetrj = _route.size() -1 ; j < sizetrj; j ++)
for( size_t k = j+1, sizetrk = _route.size(); k < sizetrk ; k++)
{
costInsertion = distance(dist,_route[i] , customer_id) + distance (dist, customer_id, _route[j]) + distance (dist, _route[i+1],_route[k]) + distance(dist,_route[j+1],_route[k+1])
-
distance (dist, _route[i],_route[i+1]) + distance (dist, _route[j], _route[j+1]) + distance(dist,_route[k],_route[k+1]);
positionTour = i+1;
_tempRoute = _route ;
tempNodes.clear() ;
tempNodes.push_back(j);
tempNodes.push_back(k);
InsertionTypeOne(_tempRoute,positionTour,customer_id,tempNodes);
double dueTime = getTimeOfService(_tempRoute, lastServedCustomer_id, serviceTime) + distance (dist,_tempRoute.back() , 0);
double demandTour = getCapacityUsed(_tempRoute);
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < lowCostInsertion))
{
lowCostInsertion= costInsertion;
lowPosition = positionTour;
_GenTempRoute = _tempRoute;
feasibleInsertion = true;
}
}
}
}
}else
{
_tempRoute = _route ;
positionTour = _tempRoute.size();
_tempRoute.push_back(customer_id);
costInsertion = distance(dist,_tempRoute.back(), customer_id) + distance(dist,customer_id, 0) - distance(dist,_tempRoute.back(),0) ;
double dueTime = getTimeOfService(_tempRoute, lastServedCustomer_id, serviceTime) + distance (dist,_tempRoute.back() , 0);
double demandTour = getCapacityUsed(_tempRoute) + clients[customer_id].demand;
if (dueTime <= depotTimeWindow && demandTour <= VEHICULE_CAPACITY )
{
if ((!feasibleInsertion) || (costInsertion < lowCostInsertion))
{
lowCostInsertion= costInsertion;
lowPosition = positionTour;
_GenTempRoute = _tempRoute;
feasibleInsertion = true;
}
}
}
if(feasibleInsertion)
if( !commitCustomer || lowCostInsertion < generalizedTourCost )
{
generalizedTourCost = lowCostInsertion;
positionGeneralizedTour = lowPosition;
generalizedTour = indexTour;
_Genroute = _GenTempRoute;
commitCustomer = true;
}
}
/*
double computTourLength(const Routes _routes)
{
double Length = 0.0 ;
for(size_t tr = 0, tsize = _routes.size(); tr < tsize; ++tr )
{
for (size_t i = 0, size = _routes[tr].size()-1; i < size; ++i )
Length+= distance(dist,_routes[tr][i], _routes[tr][i+1]);
Length+= distance(dist,_routes[tr].back(),0);
}
return Length ;
}
*/
unsigned bestNeighborhoodRoutes ( const std::vector<Routes> _neighborhoodRoutes, unsigned _bestNeighborIndex, double _bestNeighbor_fitness)
{
double minFitness, fitnessRoute ;
unsigned minRoute ;
minFitness = computTourLength(_neighborhoodRoutes[0]);
minRoute = 0;
for (size_t i =1, size = _neighborhoodRoutes.size(); i < size ; i++ )
{ fitnessRoute = computTourLength(_neighborhoodRoutes[i]) ;
if(fitnessRoute < minFitness)
{ minFitness = fitnessRoute;
minRoute = i ;
}
}
_bestNeighborIndex = minRoute;
_bestNeighbor_fitness = minFitness ;
}
void swapCustomers(Route &_route, unsigned _lastCustomerPosition)
{
unsigned customer1 = randPosition(_lastCustomerPosition + 1 , _route.size());
unsigned customer2 = randPosition(_lastCustomerPosition +1 , _route.size());
swap(_route[customer1],_route[customer2]);
}
bool twoOptOnRoute( Route & _route , unsigned _lastServedCustomerPosition)
{
bool twoOptFeasible = false ;
for (unsigned from = _lastServedCustomerPosition , size1 = _route.size() ; from < size1 -1 ; from ++)
for(unsigned to = from +1 , size2 = _route.size(); to < size2 ; to ++)
if( GainCost(_route,from,to) > 0 )
{
int idx =(to-from)/2;
for(unsigned k = 1; k <= idx ;k++)
std::swap(_route[from+k],_route[to-k]);
twoOptFeasible = true;
}
return twoOptFeasible;
}
void InsertionTypeOne(Route & _route, unsigned positionGeneralizedTour, unsigned customer_id, std::vector <unsigned> vertices)
{
_route.insert(_route.begin() + positionGeneralizedTour, customer_id );
unsigned j = vertices[0];
unsigned k = vertices[1];
_route.insert(_route.begin() + positionGeneralizedTour + 1, _route[j+1]);
_route.erase(_route.begin() + j + 2);
unsigned to = k + 1;
unsigned from = positionGeneralizedTour + 2;
int idx =( to - from )/2;
for(unsigned q = 1; q <= idx ;q++)
std::swap(_route[from+q],_route[to-q]);
}
void threeMoveRoute(Route & _route, unsigned _from, unsigned _to, unsigned _end)
{
Route tempRoute;
for(size_t i=0; i<= _from; i++)
tempRoute.push_back(_route[i]);
tempRoute.push_back( _route[_to + 1]);
tempRoute.push_back(_route[_end]);
for(size_t i=_from +1; i<= _to; i++)
tempRoute.push_back(_route[i]);
tempRoute.push_back(_route[_end+1]);
for(size_t i=_to +2; i<_end; i++)
tempRoute.push_back(_route[i]);
for(size_t i=_end + 2; i<_route.size(); i++)
tempRoute.push_back(_route[i]);
_route = tempRoute;
}
bool threeOptOnRoute( Route & _route , unsigned _lastServedCustomerPosition)
{
bool threeOptFeasible = false ;
for (unsigned from = _lastServedCustomerPosition , size1 = _route.size()-3 ; from < size1 ; from ++)
for(unsigned to = from +1 , size2 = _route.size()-2; to < size2; to ++)
for(unsigned end= to + 1, size3 = _route.size()-1 ; end < size3; end++)
if( GainCost(_route,from,to,end) > 0 )
{
//threeMoveRoute(_route,from,to,end);
if (!threeOptFeasible) threeOptFeasible = true;
}
return threeOptFeasible;
}
double GainCost(Route _route, unsigned _from, unsigned _to)
{
double Gain ;
Gain= (distance (dist, _route[_from], _route[(_from +1) % _route.size()]) + distance(dist, _route[_to - 1], _route[_to % _route.size()]))
-
(distance (dist, _route[_from],_route[_to - 1]) + distance(dist, _route[(_from+1)%_route.size()],_route[_to% _route.size()]));
return Gain;
}
double GainCost(Route _route, unsigned _from, unsigned _to, unsigned _end)
{
double Gain;
Gain = distance (dist, _route[_from],_route[(_from +1) % _route.size()]) +
distance(dist, _route[_to], _route[(_to + 1) % _route.size()]) +
distance (dist,_route[_end],_route[(_end + 1) % _route.size()])
-
distance (dist, _route[_from],_route[(_to + 1) % _route.size()]) +
distance(dist, _route[_to], _route[(_end + 1) % _route.size()]) +
distance (dist,_route[_end],_route[(_from + 1) % _route.size()]);
return Gain;
}
Reference in a new issue View git blame Copy permalink