Context Navigation

← Previous Change
Next Change →

Changeset 8327 for branches/ScatterSearch (trunk integration)

Timestamp:

07/25/12 14:28:42 (12 years ago)

Author:

jkarder

Message:

#1331: applied the rest of the changes suggested by ascheibe in comment:32:ticket:1331

Location:

branches/ScatterSearch (trunk integration)

Files:

: 12 edited

Legend:

: Unmodified
: Added
: Removed

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.Knapsack/3.3/Improvers/KnapsackImprovementOperator.cs

r8320	r8327
39	39	/// The operator first orders the elements of the knapsack according to their value-to-weight ratio, then, if the solution is not feasible, removes the element with the lowest ratio until the solution is feasible and tries to add new elements with the best ratio that are not already included yet until the knapsack is full.
40	40	/// </remarks>
41		[Item("KnapsackImprovementOperator", "An operator that improves knapsack solutions.")]
	41	[Item("KnapsackImprovementOperator", "An operator that improves knapsack solutions. It is implemented as described in Laguna, M. and Martí, R. (2003). Scatter Search: Methodology and Implementations in C. Operations Research/Computer Science Interfaces Series, Vol. 24. Springer.")]
42	42	[StorableClass]
43	43	public sealed class KnapsackImprovementOperator : SingleSuccessorOperator, ISingleObjectiveImprovementOperator {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.Knapsack/3.3/PathRelinkers/KnapsackPathRelinker.cs

r8319	r8327
37	37	/// The operator incrementally assimilates the initiating solution into the guiding solution by adding and removing elements as needed.
38	38	/// </remarks>
39		[Item("KnapsackPathRelinker", "An operator that relinks paths between knapsack solutions.")]
	39	[Item("KnapsackPathRelinker", "An operator that relinks paths between knapsack solutions. The operator incrementally assimilates the initiating solution into the guiding solution by adding and removing elements as needed.")]
40	40	[StorableClass]
41	41	public sealed class KnapsackPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.Knapsack/3.3/PathRelinkers/KnapsackSimultaneousPathRelinker.cs

r8319	r8327
37	37	/// The operator incrementally assimilates the initiating solution into the guiding solution and vice versa by adding and removing elements as needed.
38	38	/// </remarks>
39		[Item("KnapsackSimultaneousPathRelinker", "An operator that relinks paths between knapsack solutions starting from both ends.")]
	39	[Item("KnapsackSimultaneousPathRelinker", "An operator that relinks paths between knapsack solutions starting from both ends. The operator incrementally assimilates the initiating solution into the guiding solution and vice versa by adding and removing elements as needed.")]
40	40	[StorableClass]
41	41	public sealed class KnapsackSimultaneousPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.Knapsack/3.3/SimilarityCalculators/KnapsackSimilarityCalculator.cs

r8319	r8327
33	33	/// The operator calculates the similarity based on the number of elements the two solutions have in common.
34	34	/// </remarks>
35		[Item("KnapsackSimilarityCalculator", "An operator that performs similarity calculation between two knapsack solutions.")]
	35	[Item("KnapsackSimilarityCalculator", "An operator that performs similarity calculation between two knapsack solutions. The operator calculates the similarity based on the number of elements the two solutions have in common.")]
36	36	public sealed class KnapsackSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
37	37	private KnapsackSimilarityCalculator(bool deserializing) : base(deserializing) { }

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs

r8322	r8327
39	39	/// The operator uses an implementation of the Nelder-Mead method with adaptive parameters as described in Gao, F. and Han, L. (2010). Implementing the Nelder-Mead simplex algorithm with adaptive parameters. Computational Optimization and Applications, Vol. 51. Springer. and conducts relection, expansion, contraction and reduction on the test functions solution.
40	40	/// </remarks>
41		[Item("SingleObjectiveTestFunctionImprovementOperator", "An operator that improves test functions solutions.")]
	41	[Item("SingleObjectiveTestFunctionImprovementOperator", "An operator that improves test functions solutions. It is implemented as described in Laguna, M. and Martí, R. (2003). Scatter Search: Methodology and Implementations in C. Operations Research/Computer Science Interfaces Series, Vol. 24. Springer.")]
42	42	[StorableClass]
43	43	public sealed class SingleObjectiveTestFunctionImprovementOperator : SingleSuccessorOperator, ISingleObjectiveImprovementOperator {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TestFunctions/3.3/PathRelinkers/SingleObjectiveTestFunctionPathRelinker.cs

-                      r8322
+                      r8327
   /// </summary>
   /// <remarks>
   /// It is implemented as described in Duarte, A., Martí, R., and Gortazar, F. (2011). Path Relinking for Large Scale Global Optimization. Soft Computing, Vol. 15.
+  /// It is based on an implementation described in Duarte, A., Martí, R., and Gortazar, F. (2011). Path Relinking for Large Scale Global Optimization. Soft Computing, Vol. 15.<br />
   /// The operator incrementally assimilates the initiating solution into the guiding solution by adapting the solution vector's elements.
   /// </remarks>
   [Item("SingleObjectiveTestFunctionPathRelinker", "An operator that relinks paths between test functions solutions.")]
+  [Item("SingleObjectiveTestFunctionPathRelinker", "An operator that relinks paths between test functions solutions. It is based on an implementation described in Duarte, A., Martí, R., and Gortazar, F. (2011). Path Relinking for Large Scale Global Optimization. Soft Computing, Vol. 15.")]
   [StorableClass]
   public sealed class SingleObjectiveTestFunctionPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs

r8319	r8327
35	35	/// The operator calculates the similarity based on the euclidean distance of the two solutions in n-dimensional space.
36	36	/// </remarks>
37		[Item("SingleObjectiveTestFunctionSimilarityCalculator", "An operator that performs similarity calculation between two test functions solutions.")]
	37	[Item("SingleObjectiveTestFunctionSimilarityCalculator", "An operator that performs similarity calculation between two test functions solutions. The operator calculates the similarity based on the euclidean distance of the two solutions in n-dimensional space.")]
38	38	[StorableClass]
39	39	public sealed class SingleObjectiveTestFunctionSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TravelingSalesman/3.3/Improvers/TSPImprovementOperator.cs

r8319	r8327
37	37	/// The operator tries to improve the traveling salesman solution by swapping two randomly chosen edges for a certain number of times.
38	38	/// </remarks>
39		[Item("TSPImprovementOperator", "An operator that improves traveling salesman solutions.")]
	39	[Item("TSPImprovementOperator", "An operator that improves traveling salesman solutions. The operator tries to improve the traveling salesman solution by swapping two randomly chosen edges for a certain number of times.")]
40	40	[StorableClass]
41	41	public sealed class TSPImprovementOperator : SingleSuccessorOperator, ISingleObjectiveImprovementOperator {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TravelingSalesman/3.3/PathRelinkers/TSPMultipleGuidesPathRelinker.cs

r8322	r8327
38	38	/// The operator incrementally changes the initiating solution towards the guiding solution by correcting edges as needed. For each city it choses the best edge from all guiding solutions.
39	39	/// </remarks>
40		[Item("TSPMultipleGuidesPathRelinker", "An operator that relinks paths between traveling salesman solutions using a multiple guiding strategy.")]
	40	[Item("TSPMultipleGuidesPathRelinker", "An operator that relinks paths between traveling salesman solutions using a multiple guiding strategy. The operator incrementally changes the initiating solution towards the guiding solution by correcting edges as needed. For each city it choses the best edge from all guiding solutions.")]
41	41	[StorableClass]
42	42	public sealed class TSPMultipleGuidesPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TravelingSalesman/3.3/PathRelinkers/TSPPathRelinker.cs

r8319	r8327
37	37	/// The operator incrementally assimilates the initiating solution into the guiding solution by correcting edges as needed.
38	38	/// </remarks>
39		[Item("TSPPathRelinker", "An operator that relinks paths between traveling salesman solutions.")]
	39	[Item("TSPPathRelinker", "An operator that relinks paths between traveling salesman solutions. The operator incrementally assimilates the initiating solution into the guiding solution by correcting edges as needed.")]
40	40	[StorableClass]
41	41	public sealed class TSPPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TravelingSalesman/3.3/PathRelinkers/TSPSimultaneousPathRelinker.cs

r8319	r8327
37	37	/// The operator incrementally assimilates the initiating solution into the guiding solution and vice versa by correcting edges as needed.
38	38	/// </remarks>
39		[Item("TSPSimultaneousPathRelinker", "An operator that relinks paths between traveling salesman solutions starting from both ends.")]
	39	[Item("TSPSimultaneousPathRelinker", "An operator that relinks paths between traveling salesman solutions starting from both ends. The operator incrementally assimilates the initiating solution into the guiding solution and vice versa by correcting edges as needed.")]
40	40	[StorableClass]
41	41	public sealed class TSPSimultaneousPathRelinker : SingleObjectivePathRelinker {

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.TravelingSalesman/3.3/SimilarityCalculators/TSPSimilarityCalculator.cs

r8322	r8327
33	33	/// The operator calculates the similarity based on the number of edges the two solutions have in common.
34	34	/// </remarks>
35		[Item("TSPSimilarityCalculator", "An operator that performs similarity calculation between two traveling salesman solutions.")]
	35	[Item("TSPSimilarityCalculator", "An operator that performs similarity calculation between two traveling salesman solutions. The operator calculates the similarity based on the number of edges the two solutions have in common.")]
36	36	public sealed class TSPSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
37	37	private TSPSimilarityCalculator(bool deserializing) : base(deserializing) { }

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats:

Update cookies preferences