public void ReOptimization(string optimizationProblemID)
{
// Create the manager with the api key
Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
OptimizationParameters optimizationParameters = new OptimizationParameters()
{
OptimizationProblemID = optimizationProblemID,
ReOptimize = true
};
// Run the query
string errorString;
DataObject dataObject = route4Me.UpdateOptimization(optimizationParameters, out errorString);
Console.WriteLine("");
if (dataObject != null)
{
Console.WriteLine("ReOptimization executed successfully");
Console.WriteLine("Optimization Problem ID: {0}", dataObject.OptimizationProblemId);
Console.WriteLine("State: {0}", dataObject.State);
}
else
{
Console.WriteLine("ReOptimization error: {0}", errorString);
}
}
public void GetOptimizations()
{
// Create the manager with the api key
Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
OptimizationParameters queryParameters = new OptimizationParameters()
{
Limit = 10,
Offset = 5
};
// Run the query
string errorString;
DataObject[] dataObjects = route4Me.GetOptimizations(queryParameters, out errorString);
Console.WriteLine("");
if (dataObjects != null)
{
Console.WriteLine("GetOptimizations executed successfully, {0} optimizations returned", dataObjects.Length);
Console.WriteLine("");
dataObjects.ForEach(optimization =>
{
Console.WriteLine("Optimization Problem ID: {0}", optimization.OptimizationProblemId);
Console.WriteLine("");
});
}
else
{
Console.WriteLine("GetOptimizations error: {0}", errorString);
}
}
/// <summary>
/// Finds parameters to be used for optimization for the given Strategy and displays on UI
/// </summary>
private void OptimizationParameterDetails()
{
// Clear existing data
OptimizationParameters.Clear();
// Contains custom defined attributes in the given assembly
Dictionary <int, Tuple <string, Type> > customAttributes = null;
// Get Custom Attributes
if (_selectedStrategy.StrategyType != null)
{
// Get custom attributes from the given assembly
customAttributes = StrategyHelper.GetCustomAttributes(_selectedStrategy.StrategyType);
foreach (KeyValuePair <int, Tuple <string, Type> > keyValuePair in customAttributes)
{
var parameter = new OptimizationParameterDetail();
parameter.Index = keyValuePair.Key;
parameter.Description = keyValuePair.Value.Item1;
parameter.ParameterType = keyValuePair.Value.Item2;
// Add to observable collection to display on UI
OptimizationParameters.Add(parameter);
}
}
}
public GeneticPathFinding(int[] order, OptimizationParameters parameters, DelegateFitness.CalcFitness calcFitness, CancellationToken ct, Random random)
{
var populationInitialization = new StandardPathInitialization(random);
var population = populationInitialization.InitializePopulation(order, parameters.PopulationSize, 0);
_genetic = new BaseGenetic(parameters, population, calcFitness, ct, random);
}
public void GetOptimizationsByText()
{
var route4Me = new Route4MeManager(ActualApiKey);
RunOptimizationSingleDriverRoute10Stops();
OptimizationsToRemove = new List <string>();
OptimizationsToRemove.Add(SD10Stops_optimization_problem_id);
string queryText = "SD Route 10 Stops Test";
var queryParameters = new OptimizationParameters()
{
Limit = 3,
Offset = 0,
Query = queryText
};
// Run the query
var dataObjects = route4Me.GetOptimizations(
queryParameters,
out string errorString);
int foundOptimizations = dataObjects
.Where(x => x.Parameters.RouteName.Contains(queryText))
.Count();
Console.WriteLine(
foundOptimizations > 0
? "Found the optimizations searched by text: " + foundOptimizations
: "Cannot found the optimizations searched by text"
);
RemoveTestOptimizations();
}
/// <summary>
/// Re-optimize an optimization
/// </summary>
/// <param name="optimizationProblemID">Optimization problem ID</param>
public void ReOptimization(string optimizationProblemID = null)
{
// Create the manager with the api key
var route4Me = new Route4MeManager(ActualApiKey);
bool isInnerExample = optimizationProblemID == null ? true : false;
if (isInnerExample)
{
RunOptimizationSingleDriverRoute10Stops();
optimizationProblemID = SD10Stops_optimization_problem_id;
OptimizationsToRemove = new List <string>();
OptimizationsToRemove.Add(optimizationProblemID);
}
var optimizationParameters = new OptimizationParameters()
{
OptimizationProblemID = optimizationProblemID,
ReOptimize = true
};
// Run the query
DataObject dataObject = route4Me.UpdateOptimization(
optimizationParameters,
out string errorString);
PrintExampleOptimizationResult(dataObject, errorString);
if (isInnerExample)
{
RemoveTestOptimizations();
}
}
protected OptimizationStep(OptimizationParameters parameters, Population population)
{
this.BestFitness = double.MaxValue;
this.parameters = parameters;
this.population = population;
bestFitnessCounter = FitnessCounterFactory.GetFitnessCounterForBest(parameters);
}
public void Save(string name, OptimizationParameters parameters)
{
Logger.Instance.AddLine($"Saving {name} optimization parameters");
Directory.CreateDirectory(Path.Combine(directory, name));
Save(parameters, Path.Combine(directory, name, typeof(OptimizationParameters).Name));
}
private static void Run()
{
Logger.Instance.AddLine("Loading local optimization parametetrs");
optimizationParameters = repository.LoadOptimizationParametersByPath("OptimizationParameters.xml");
Logger.Instance.AddLine("Starting optimization");
Start();
}
public Log(OptimizationParameters optimizationParameters)
{
_stringBuilder = new StringBuilder();
_path = optimizationParameters.LogPath;
_resultPath = optimizationParameters.ResultPath;
_logEnabled = optimizationParameters.LogEnabled;
File.Delete(_path);
}
private static void LoadOptimizationParameters()
{
Logger.Instance.AddLine("Insert full path of optimization parameters:");
var optimizationParametersPath = Console.ReadLine();
Logger.Instance.AddLine(optimizationParametersPath);
optimizationParameters = repository.LoadOptimizationParametersByPath(optimizationParametersPath);
}
public static double FindShortestPath(OptimizationParameters optimizationParameters, CancellationToken ct, int seed = 0)
{
seed = GetSeed(seed);
var random = new Random(seed);
var matrix = Files.ReadArray(optimizationParameters.DataPath);
Distances.Create(matrix);
return(PathFinding.ShortestPath.Find(PointsArrayGenerator.GeneratePointsToVisit(matrix.Length), optimizationParameters, ct, random));
}
public static void KeyboardOptimization(OptimizationParameters optimizationParameters, int seed = 0)
{
seed = GetSeed(seed);
var random = new Random(seed);
var keyboardOptimizer = new GeneticKeyboard(optimizationParameters, random);
var result = keyboardOptimizer.Run();
keyboardOptimizer.WriteResult(result);
}
public Optimization(OptimizationParameters parameters,
Population population,
ISimulationRepository repository,
IFitnessCounter controlFitnessCounter)
{
this.parameters = parameters;
this.population = population;
this.repository = repository;
this.controlFitnessCounter = controlFitnessCounter;
}
private static void Load()
{
Logger.Instance.AddLine("Insert name of simulation:");
var name = Console.ReadLine();
Logger.Instance.AddLine(name);
optimizationParameters = repository.LoadOptimizationParameters(name);
population = repository.LoadPopulation(name, optimizationParameters);
}
public static void FindShortestPath(OptimizationParameters optimizationParameters,
DelegateFitness.CalcFitness calcFitness, int seed = 0)
{
seed = GetSeed(seed);
var random = new Random(seed);
var matrix = Files.ReadArray(optimizationParameters.DataPath);
Distances.Create(matrix);
PathFinding.ShortestPath.Find(PointsArrayGenerator.GeneratePointsToVisit(matrix.Length), optimizationParameters, calcFitness, CancellationToken.None, random);
}
public async void Execute(object?parameter)
{
var vm = parameter as DistanceViewModel;
if (!Directory.Exists(vm.DistanceParameters.ResultPath))
{
Directory.CreateDirectory(vm.DistanceParameters.ResultPath);
}
vm.IsDistanceStartButtonEnabled = false;
EventHandler <int> BaseGeneticOnOnNextIteration()
{
return((sender, iteration) =>
{
vm.ProgressBarValue++;
});
}
vm.DistanceParameters.DataPath = vm.SelectedFiles[0];
OptimizationParameters parameters = vm.DistanceParameters as OptimizationParameters;
int runs = vm.Runs;
int seed = vm.CurrentSeed;
if (vm.RandomSeed)
{
Random random = new Random();
seed = random.Next(1, Int32.MaxValue);
vm.CurrentSeed = seed;
}
TSPResult[] results = new TSPResult[runs];
double[][][] runFitnesses = new double[runs][][];
vm.CancellationTokenSource = new CancellationTokenSource();
vm.ProgressBarMaximum = runs * vm.DistanceParameters.MaxEpoch - 1;
vm.ProgressBarValue = 0;
Optimization.GeneticAlgorithms.BaseGenetic.OnNextIteration += BaseGeneticOnOnNextIteration();
CancellationToken ct = vm.CancellationTokenSource.Token;
if (vm.DistanceParameters.OptimizationMethod == OptimizationMethod.GeneticAlgorithm)
{
Directory.CreateDirectory(vm.DistanceParameters.ResultPath + "\\" + seed.ToString());
//SerializeParameters(vm.DistanceParameters.ResultPath + "\\" + seed + "/parameters.json");
Application.Current.MainWindow.Cursor = Cursors.Wait;
await Task.Run(() =>
{
foreach (var dataset in vm.SelectedFiles)
{
var s = "epoch;best_distance;avg_best_10%;median;avg_worst_10%;avg;worst_distance;std_deviation;conflict_percentage;avgDiff;0Diff;02Diff\n";
vm.DistanceParameters.DataPath = dataset;
var fileName = seed + "/" + runs + "_BEST_" + vm.DistanceParameters.DataPath.Split("\\")[^ 1] + ".txt";
/// <summary>
/// Creates a deep copy of <see cref="IdentificationModel"/> instance
/// </summary>
/// <returns>Deep copy of self</returns>
public object Clone()
{
return(new IdentificationModel()
{
IdentificationExperiments = (IdentificationExperimentCollection)IdentificationExperiments.Clone(),
RealExperiments = (ExperimentCollection)RealExperiments.Clone(),
IdentificationParameters = (ParameterCollection)IdentificationParameters.Clone(),
OptimizationParameters = (ParameterCollection)OptimizationParameters.Clone(),
Criteria = (CriterionCollection)Criteria.Clone(),
FunctionalConstraints = (ConstraintCollection)FunctionalConstraints.Clone(),
Properties = (PropertyCollection)Properties.Clone()
});
}
public GeneticKeyboard(OptimizationParameters optimizationParameters, Random random)
{
int[][] population = InitializeKeyboardPopulation(optimizationParameters.PopulationSize);
_genetic = new BaseGenetic(optimizationParameters, population, pop =>
{
double[] fitness = new double[pop.Length];
for (int i = 0; i < pop.Length; i++)
{
fitness[i] = Fitness.CalculateFitness(pop[i], _frequency, _weights);
}
return(fitness);
}, CancellationToken.None, random);
}
private static void Continue()
{
var name = repository.GetNewestSimulationName();
if (string.IsNullOrEmpty(name))
{
Logger.Instance.AddLine("No saved simulation to continue");
}
optimizationParameters = repository.LoadOptimizationParameters(name);
population = repository.LoadPopulation(name, optimizationParameters);
Start();
}
public Selection(OptimizationParameters optimizationParameters, Population population, int numberOfWinners)
{
this.population = population;
this.numberOfWinners = numberOfWinners;
this.numberOfParticipants = optimizationParameters.NumberOfParticipants;
var randomSets = new RandomSetsList(
optimizationParameters.NumberOfRandomSets,
optimizationParameters.NumberOfShepherds,
optimizationParameters.NumberOfSheep,
StaticRandom.R.Next());
this.fitnessCounter = FitnessCounterFactory.GetFitnessCounterForTraining(optimizationParameters);
}
public static Elimination CreateElimination(OptimizationParameters optimizationParameters, int[][] population, Random random)
{
Elimination elimination = optimizationParameters.EliminationMethod switch
{
EliminationMethod.Elitism => new ElitismElimination(population, random),
EliminationMethod.RouletteWheel => new RouletteWheelElimination(population, random),
EliminationMethod.Tournament => new TournamentElimination(population, random)
{
ParticipantsCount = optimizationParameters.TournamentEliminationParticipantsCount
},
_ => throw new ArgumentException("Wrong elimination method name")
};
return(elimination);
}
public static ConflictResolver CreateConflictResolver(OptimizationParameters parameters, ConflictResolveMethod method, Random random, int tournamentParticipants)
{
ConflictResolver resolver = method switch
{
ConflictResolveMethod.Random => new RandomResolver(random, parameters.ResolveRandomizationProbability),
ConflictResolveMethod.NearestNeighbor => new NearestNeighborResolver(random, parameters.ResolveRandomizationProbability),
ConflictResolveMethod.Tournament => new TournamentResolver(random, parameters.ResolveRandomizationProbability),
ConflictResolveMethod.WarehouseSingleProductFrequency => new WarehouseSingleProductFrequencyResolver(random, parameters.ResolveRandomizationProbability, tournamentParticipants),
ConflictResolveMethod.WarehousePairwiseProductFrequency => new WarehousePairwiseProductFrequencyResolver(random, parameters.ResolveRandomizationProbability, tournamentParticipants),
ConflictResolveMethod.WarehouseSigleAndPairwiseResolver => new WarehouseSigleAndPairwiseResolver(random, parameters.ResolveRandomizationProbability, tournamentParticipants),
_ => throw new ArgumentException("Wrong conflict resolve method name")
};
return(resolver);
}
public static Selection CreateSelection(OptimizationParameters optimizationParameters, int[][] population, Random random)
{
Selection selection = optimizationParameters.SelectionMethod switch
{
SelectionMethod.Random => new RandomSelection(population, random),
SelectionMethod.Tournament => new TournamentSelection(population, random)
{
ParticipantsCount = optimizationParameters.TournamentSelectionParticipantsCount
},
SelectionMethod.Elitism => new ElitismSelection(population, random),
SelectionMethod.RouletteWheel => new RouletteWheelSelection(population, random),
_ => throw new ArgumentException("Wrong selection name in parameters json file")
};
return(selection);
}
private static void Start()
{
if (optimizationParameters == null)
{
Logger.Instance.AddLine("Attempt to load optimization paramaters from default location");
optimizationParameters = repository.LoadOptimizationParametersByPath("OptimizationParameters.xml");
}
if (population == null)
{
Logger.Instance.AddLine("Generating new population");
population = new Population(optimizationParameters);
}
Logger.Instance.AddLine("Starting optimization");
new Optimization(optimizationParameters, population, repository, controlFitnessCounter).Optimize();
}
public DataObject AddDestinationToOptimization(string optimizationProblemID, bool andReOptimize)
{
// Create the manager with the api key
Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
// Prepare the address that we are going to add to an existing route optimization
Address[] addresses = new Address[]
{
new Address()
{
AddressString = "717 5th Ave New York, NY 10021",
Alias = "Giorgio Armani",
Latitude = 40.7669692,
Longitude = -73.9693864,
Time = 0
}
};
//Optionally change any route parameters, such as maximum route duration, maximum cubic constraints, etc.
OptimizationParameters optimizationParameters = new OptimizationParameters()
{
OptimizationProblemID = optimizationProblemID,
Addresses = addresses,
ReOptimize = andReOptimize
};
// Execute the optimization to re-optimize and rebalance all the routes in this optimization
string errorString;
DataObject dataObject = route4Me.UpdateOptimization(optimizationParameters, out errorString);
Console.WriteLine("");
if (dataObject != null)
{
Console.WriteLine("AddDestinationToOptimization executed successfully");
Console.WriteLine("Optimization Problem ID: {0}", dataObject.OptimizationProblemId);
Console.WriteLine("State: {0}", dataObject.State);
}
else
{
Console.WriteLine("AddDestinationToOptimization error: {0}", errorString);
}
return(dataObject);
}
public GeneticWarehouse(OptimizationParameters optimizationParameters, int warehouseSize,
DelegateFitness.CalcFitness calcFitness, CancellationToken ct, Random random)
{
_warehouseSize = warehouseSize;
int[] itemsToSort = new int[_warehouseSize];
for (int i = 1; i < _warehouseSize; i++)
{
itemsToSort[i - 1] = i;
}
var populationInitialization = new StandardPathInitialization(random);
var population = populationInitialization.InitializePopulation(itemsToSort, optimizationParameters.PopulationSize, 0);
_genetic = new BaseGenetic(optimizationParameters, population, calcFitness, ct, random);
wm = new WarehouseModule();
_genetic.LoadModule(wm);
}
/// <summary>
/// Get limited number of the optimizations.
/// </summary>
public void GetOptimizations()
{
// Create the manager with the api key
var route4Me = new Route4MeManager(ActualApiKey);
var queryParameters = new OptimizationParameters()
{
Limit = 10,
Offset = 5
};
// Run the query
DataObject[] dataObjects = route4Me.GetOptimizations(
queryParameters,
out string errorString);
PrintExampleOptimizationResult(dataObjects, errorString);
}
/// <summary>
/// Add a destination to an optimization.
/// </summary>
public void AddDestinationToOptimization()
{
// Create the manager with the api key
var route4Me = new Route4MeManager(ActualApiKey);
RunOptimizationSingleDriverRoute10Stops();
OptimizationsToRemove = new List <string>()
{
SD10Stops_optimization_problem_id
};
// Prepare the address that we are going to add to an existing route optimization
Address[] addresses = new Address[]
{
new Address()
{
AddressString = "717 5th Ave New York, NY 10021",
Alias = "Giorgio Armani",
Latitude = 40.7669692,
Longitude = -73.9693864,
Time = 0
}
};
//Optionally change any route parameters, such as maximum route duration, maximum cubic constraints, etc.
OptimizationParameters optimizationParameters = new OptimizationParameters()
{
OptimizationProblemID = SD10Stops_optimization_problem_id,
Addresses = addresses,
ReOptimize = true
};
// Execute the optimization to re-optimize and rebalance all the routes in this optimization
DataObject dataObject = route4Me.UpdateOptimization(
optimizationParameters,
out string errorString);
PrintExampleOptimizationResult(dataObject, errorString);
RemoveTestOptimizations();
}
public static PathFindingResult GetPathAndFitness(int[] order, OptimizationParameters optimizationParameters,
CancellationToken ct, Random random)
{
IPathFinder algorithmPathFinding = optimizationParameters.OptimizationMethod switch
{
OptimizationMethod.Permutations => new Permutations(optimizationParameters),
OptimizationMethod.NearestNeighbor => new NearestNeighbor(optimizationParameters),
OptimizationMethod.GeneticAlgorithm => new GeneticPathFinding(order, optimizationParameters,
(population) =>
{
double[] fitness = new double[population.Length];
for (int i = 0; i < population.Length; i++)
{
fitness[i] = Fitness.CalculateFitness(population[i]);
}
return(fitness);
}, ct, random),
_ => throw new ArgumentException("Incorrect optimization method in config file")
};
int[] objectOrder = algorithmPathFinding.FindShortestPath(order);
if (optimizationParameters.Use2opt)
{
objectOrder = Optimizer2Opt.Optimize(objectOrder);
}
double pathLength = Fitness.CalculateFitness(objectOrder);
if (optimizationParameters.ResultToFile)
{
Log log = new Log(optimizationParameters);
log.SaveResult(objectOrder, pathLength);
}
return(new PathFindingResult()
{
Path = objectOrder,
Fitness = pathLength
});
}
}
