// Constructor
public Parameters(
CluVRPVersion CluVRP_Version,
int CluVRP_GRASPIterations,
int CluVRP_LS_Main_Iterations,
int CluVRP_LS_SwapClusters,
int CluVRP_LS_SwapVehicle,
int Cluster_GRASPIterations,
double Cluster_AlphaCapacity,
double Cluster_AlphaDistance,
FitAlgorithm Cluster_FitAlgoritm,
int[] Cluster_LS_Order,
int Cluster_LS_SwapVehicle,
int Cluster_LS_InsertVehicle,
int Cluster_LS_SwapClusters,
//int Cluster_LS_RndSwapVehicle,
//int Cluster_LS_RndInsertVehicle,
int Cluster_LS_TwoOpt_Iterations,
int Cluster_LS_Relocate_Iterations,
int Cluster_LS_Exchange_Iterations,
int Customer_GRASPIterations,
double Customer_Alpha,
int[] Customer_LS_Order,
int Customer_LS_SwapCustomers,
int Customer_LS_TwoOpt_Iterations,
int Customer_LS_Relocate_Iterations,
int Customer_LS_Exchange_Iterations)
{
// CluVRP
this.CluVRP_Version = CluVRP_Version;
this.CluVRP_GRASPIterations = CluVRP_GRASPIterations;
this.CluVRP_LS_Main_Iterations = CluVRP_LS_Main_Iterations;
this.CluVRP_LS_SwapClusters = CluVRP_LS_SwapClusters;
this.CluVRP_LS_SwapVehicle = CluVRP_LS_SwapVehicle;
// Cluster Level
this.Cluster_GRASPIterations = Cluster_GRASPIterations;
this.Cluster_AlphaCapacity = Cluster_AlphaCapacity;
this.Cluster_AlphaDistance = Cluster_AlphaDistance;
this.Cluster_FitAlgoritm = Cluster_FitAlgoritm;
this.Cluster_LS_Order = Cluster_LS_Order;
this.Cluster_LS_SwapVehicle = Cluster_LS_SwapVehicle;
this.Cluster_LS_InsertVehicle = Cluster_LS_InsertVehicle;
this.Cluster_LS_SwapClusters = Cluster_LS_SwapClusters;
//this.CluVRP_LS_SwapClusters = Cluster_LS_RndSwapVehicle;
//this.CluVRP_LS_SwapVehicle = Cluster_LS_RndInsertVehicle;
this.Cluster_LS_TwoOpt_Iterations = Cluster_LS_TwoOpt_Iterations;
this.Cluster_LS_Relocate_Iterations = Cluster_LS_Relocate_Iterations;
this.Cluster_LS_Exchange_Iterations = Cluster_LS_Exchange_Iterations;
this.Customer_GRASPIterations = Customer_GRASPIterations;
// Customer Level
this.Customer_Alpha = Customer_Alpha;
this.Customer_LS_Order = Customer_LS_Order;
this.Customer_LS_SwapCustomers = Customer_LS_SwapCustomers;
this.Customer_LS_TwoOpt_Iterations = Customer_LS_TwoOpt_Iterations;
this.Customer_LS_Relocate_Iterations = Customer_LS_Relocate_Iterations;
this.Customer_LS_Exchange_Iterations = Customer_LS_Exchange_Iterations;
}
// Main call
static void Main(string[] args)
{
// Default type of clvrp
CluVRPVersion cluVRPVersion = CluVRPVersion.Strong;
// Check numbers of parameters
if (args.Length < 4)
{
Console.WriteLine(
"Parameter is missing: " + '\n' +
"Use: cluvrp_grasp parametersFilePath instanceSetFilePath logFilePath solutionsFilePath typeOfCluVRP" + '\n' + '\n'
);
return;
}
// If type of cluvrp is defined set it
else if (args.Length == 5)
{
cluVRPVersion = (CluVRPVersion)int.Parse(args[4]);
}
// Set variables
string parametersFilePath = args[0];
string instanceSetFilePath = args[1];
string logFilePath = args[2];
string solutionsFilePath = args[3];
// Check if parameters are corrects
if (!(File.Exists(parametersFilePath) && File.Exists(instanceSetFilePath) && File.Exists(solutionsFilePath)))
{
Console.WriteLine("Some parameter is incorrect or file not exists");
return;
}
// Try to parse array of solutions for compare
double[] solutionToCompare = Functions.createSolutionArrayForInstances(instanceSetFilePath, solutionsFilePath);
// Excute GRASP
GraspProcedure(parametersFilePath, instanceSetFilePath, logFilePath, solutionToCompare, cluVRPVersion);
// End
return;
}
// Main Function
static void GraspProcedure(string parametersFilePath, string instanceSetFilePath, string logFilePath, double[] solutionToCompare, CluVRPVersion cluVRPVersion)
{
// Star watch to calculate total process time
var totalWatch = System.Diagnostics.Stopwatch.StartNew();
// For watch for each instance execution
long elapsedMs = 0;
// Number of instances
int instancesNumber = solutionToCompare.Length;
// For best results
Dictionary <CluVRPInstance, CluVRPSolution> bestSolutionForInstance = new Dictionary <CluVRPInstance, CluVRPSolution>();
CluVRPSolution solution;
double[] bestSolutionTotalDistance = new double[instancesNumber];
double[] bestSolutionPropDistance = new double[instancesNumber];
double[] bestSolutionTime = new double[instancesNumber];
Functions.Populate(bestSolutionTotalDistance, double.MaxValue);
string[] bestSolutionParameters = new string[instancesNumber];
// For Average results
double[] totalDistance = new double[instancesNumber];
double[] totalTime = new double[instancesNumber];
double[] solutionAvgPropDistance = new double[instancesNumber];
int[] instanceOKsolutions = new int[instancesNumber];
// Get parameters to run instances
List <Parameters> parametersList = Parameters.parseParameterFile(parametersFilePath);
// Get logger
Logger logger = Logger.GetInstance();
// To logger verbose on/off
logger.setVerbose(false);
logger.setLogFilePath(logFilePath);
// Get instances
CluVRPInstance[] instancias = InstanceParser.loadGVRPSetOfInstances(instanceSetFilePath);
// Log run
logger.logLine("*****************************************************" + '\n' +
"* STARTING TEST:" + '\n' +
"* DATE -> " + DateTime.Now.ToString() + '\n' +
"* CONFIG -> " + parametersFilePath + '\n' +
"* SET INSTANCE -> " + instanceSetFilePath + '\n' +
"* LOG FILE -> " + logger.getLogFilePath() + '\n' +
"*****************************************************" + '\n');
// For each instance
int instanceIterator = 0;
foreach (CluVRPInstance instance in instancias)
{
// For this instance
double distance;
// Create new solution
solution = new CluVRPSolution(instance);
// For each parameter configuration
foreach (Parameters parameters in parametersList)
{
// Star watch to calculate time
var watch = System.Diagnostics.Stopwatch.StartNew();
// If CluVRP_Version in parameters is None(3) it has to be taken from command line
if (parameters.CluVRP_Version == CluVRPVersion.None)
{
parameters.CluVRP_Version = cluVRPVersion;
}
// Actual Parameter
string actualParameters = Functions.parametersToString(parameters);
//logger.logLine(actualParameters);
// Calculate solution for normal CluVRP or weak cluster constrains
solution = CluVRPGrasp.Grasp(instance, parameters);
// If not possible solution
if (solution.clusterRouteForVehicule == null)
{
continue;
}
// Increase instance OK solution iteration
instanceOKsolutions[instanceIterator]++;
// For this instance solution
distance = solution.totalCustomerRouteDistance;
// Izquierdo instances results are not integers
if (instance.instance_type == Instance.GoldenIzquierdo)
{
distance = Math.Truncate(100 * distance) / 100;
}
else
{
distance = Math.Truncate(distance);
}
// Stop timer watchers
watch.Stop();
// Set execution time
elapsedMs = watch.ElapsedMilliseconds;
double elapsedSeconds = Math.Round(elapsedMs * 1.0 / 1000, 2);
// Update solution results
totalDistance[instanceIterator] += distance;
totalTime[instanceIterator] += elapsedSeconds;
// Update individual instance solution
if (distance < bestSolutionTotalDistance[instanceIterator])
{
bestSolutionTotalDistance[instanceIterator] = distance;
bestSolutionPropDistance[instanceIterator] = (distance - solutionToCompare[instanceIterator]) * 100 / solutionToCompare[instanceIterator];
bestSolutionPropDistance[instanceIterator] = Math.Truncate(100 * bestSolutionPropDistance[instanceIterator]) / 100;
bestSolutionParameters[instanceIterator] = actualParameters;
bestSolutionTime[instanceIterator] = elapsedSeconds;
bestSolutionForInstance[instance] = solution;
}
}
// Calculate averages
double averageDistance = totalDistance[instanceIterator] / instanceOKsolutions[instanceIterator];
double averageTime = totalTime[instanceIterator] / instanceOKsolutions[instanceIterator];
averageTime = Math.Round(averageTime, 2);
double averagePropDistance = (averageDistance - solutionToCompare[instanceIterator]) * 100 / solutionToCompare[instanceIterator];
averagePropDistance = Math.Truncate(100 * averagePropDistance) / 100;
bestSolutionPropDistance[instanceIterator] = Math.Truncate(100 * bestSolutionPropDistance[instanceIterator]) / 100;
solutionAvgPropDistance[instanceIterator] = averagePropDistance;
// For log solution
string s_distance;
string s_averageDistance;
string s_bestSolutionPropDistance = bestSolutionPropDistance[instanceIterator].ToString("0.00");
string s_bestSolutionTime = bestSolutionTime[instanceIterator].ToString("0.00");
string s_averagePropDistance = averagePropDistance.ToString("0.00");
string s_averageTime = averageTime.ToString("0.00");
string s_fileName = Path.GetFileName(instancias[instanceIterator].file_name);
if (instance.instance_type == Instance.GoldenIzquierdo)
{
s_distance = bestSolutionTotalDistance[instanceIterator].ToString("0.00");
s_averageDistance = averageDistance.ToString("0.00");
}
else
{
s_distance = bestSolutionTotalDistance[instanceIterator].ToString("0");
s_averageDistance = averageDistance.ToString("0");
}
// Print solution
string outLine = s_fileName + '\t' + '\t' + s_distance + '\t' + s_bestSolutionPropDistance + "%" + '\t' + s_bestSolutionTime + "s" + '\t' + '\t' + s_averageDistance + '\t' + s_averagePropDistance + "%" + '\t' + s_averageTime + "s";
logger.logLine(outLine);
logger.logTimeAndIterations(solution, instance.file_name);
// Increase distance counter
instanceIterator++;
}
// Stop timer watchers
totalWatch.Stop();
var totalElapsedseconds = totalWatch.ElapsedMilliseconds / 1000;
// Total values
string s_totalPropBestDistance = (bestSolutionPropDistance.Sum() / instancesNumber).ToString("0.00");
string s_totalPropAvgDistance = (solutionAvgPropDistance.Sum() / instancesNumber).ToString("0.00");
// Show parameters for best solution
logger.logLine("");
logger.logLine("*************************************");
logger.logLine("* PARAMETERS FOR BEST SOLUTIONS: *");
logger.logLine("*************************************");
logger.logLine("TOTAL TIME -> " + totalElapsedseconds + " seconds");
logger.logLine("TOTAL BEST PROP DISTANCE -> " + s_totalPropBestDistance + "%");
logger.logLine("TOTAL AVG PROP DISTANCE -> " + s_totalPropAvgDistance + "%");
logger.logLine("");
for (int i = 0; i < bestSolutionParameters.Length; i++)
{
logger.logLine("-----------------------------------------------------------------");
logger.logLine("");
logger.logLine("CONFIGURATION FOR INSTANCE " + i);
logger.logLine("*****************************");
logger.logLine(bestSolutionParameters[i].ToString());
}
// Draw PNG solution
foreach (CluVRPInstance instance in bestSolutionForInstance.Keys)
{
//CluVRPSolution.solutionDrawPythonCode(instance, bestSolutionForInstance[instance]);
}
// Pause
//System.Console.ReadKey();
// End
return;
}
