Changeset 17544
- Timestamp:
- 05/18/20 18:55:08 (4 years ago)
- Location:
- branches/2521_ProblemRefactoring
- Files:
-
- 30 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
r17226 r17544 22 22 using System; 23 23 using System.Collections.Generic; 24 using System.ComponentModel; 24 25 using System.Linq; 26 using HEAL.Attic; 25 27 using HeuristicLab.Common; 26 28 using HeuristicLab.Core; … … 28 30 using HeuristicLab.Optimization; 29 31 using HeuristicLab.Parameters; 30 using HEAL.Attic;31 32 using HeuristicLab.PluginInfrastructure; 32 33 … … 34 35 [Item("BinaryVectorEncoding", "Describes a binary vector encoding.")] 35 36 [StorableType("889C5E1A-3FBF-4AB3-AB2E-199A781503B5")] 36 public sealed class BinaryVectorEncoding : Encoding<BinaryVector> {37 public sealed class BinaryVectorEncoding : Encoding<BinaryVector>, INotifyPropertyChanged { 37 38 #region Encoding Parameters 38 [Storable] 39 private IFixedValueParameter<IntValue> lengthParameter; 40 public IFixedValueParameter<IntValue> LengthParameter { 41 get { return lengthParameter; } 42 set { 43 if (value == null) throw new ArgumentNullException("Length parameter must not be null."); 44 if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null."); 45 if (lengthParameter == value) return; 46 47 if (lengthParameter != null) Parameters.Remove(lengthParameter); 48 lengthParameter = value; 49 Parameters.Add(lengthParameter); 50 OnLengthParameterChanged(); 51 } 52 } 39 [Storable] public IValueParameter<IntValue> LengthParameter { get; private set; } 53 40 #endregion 54 41 55 42 public int Length { 56 43 get { return LengthParameter.Value.Value; } 57 set { LengthParameter.Value.Value = value; } 44 set { 45 if (Length == value) return; 46 LengthParameter.ForceValue(new IntValue(value, @readonly: LengthParameter.Value.ReadOnly)); 47 } 58 48 } 59 49 … … 62 52 [StorableHook(HookType.AfterDeserialization)] 63 53 private void AfterDeserialization() { 64 RegisterParameterEvents();65 54 DiscoverOperators(); 55 RegisterEventHandlers(); 66 56 } 67 57 public override IDeepCloneable Clone(Cloner cloner) { return new BinaryVectorEncoding(this, cloner); } 68 58 private BinaryVectorEncoding(BinaryVectorEncoding original, Cloner cloner) 69 59 : base(original, cloner) { 70 lengthParameter = cloner.Clone(original.lengthParameter);71 Register ParameterEvents();60 LengthParameter = cloner.Clone(original.LengthParameter); 61 RegisterEventHandlers(); 72 62 } 73 63 … … 77 67 public BinaryVectorEncoding(string name, int length) 78 68 : base(name) { 79 lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length)); 80 Parameters.Add(lengthParameter); 69 Parameters.Add(LengthParameter = new ValueParameter<IntValue>(Name + ".Length", new IntValue(length, @readonly: true)) { ReadOnly = true }); 70 71 SolutionCreator = new RandomBinaryVectorCreator(); 72 DiscoverOperators(); 81 73 82 SolutionCreator = new RandomBinaryVectorCreator(); 83 RegisterParameterEvents(); 84 DiscoverOperators(); 74 RegisterEventHandlers(); 85 75 } 86 76 87 private void OnLengthParameterChanged() { 88 RegisterLengthParameterEvents(); 89 ConfigureOperators(Operators); 90 } 91 private void RegisterParameterEvents() { 92 RegisterLengthParameterEvents(); 93 } 94 private void RegisterLengthParameterEvents() { 95 LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators); 96 LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators); 77 private void RegisterEventHandlers() { 78 LengthParameter.ValueChanged += (_, __) => { 79 if (!LengthParameter.Value.ReadOnly) LengthParameter.Value.ValueChanged += (___, ____) => OnPropertyChanged(nameof(Length)); 80 OnPropertyChanged(nameof(Length)); 81 }; 97 82 } 98 83 99 84 #region Operator Discovery 100 85 private static readonly IEnumerable<Type> encodingSpecificOperatorTypes; 86 101 87 static BinaryVectorEncoding() { 102 88 encodingSpecificOperatorTypes = new List<Type>() { … … 169 155 } 170 156 #endregion 157 158 public event PropertyChangedEventHandler PropertyChanged; 159 private void OnPropertyChanged(string property) { 160 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(property)); 161 } 171 162 } 172 163 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorMultiObjectiveProblem.cs
r17522 r17544 26 26 using HeuristicLab.Common; 27 27 using HeuristicLab.Core; 28 using HeuristicLab.Data; 28 29 using HeuristicLab.Optimization; 30 using HeuristicLab.Parameters; 29 31 30 32 namespace HeuristicLab.Encodings.BinaryVectorEncoding { … … 33 35 [Storable] protected IResultParameter<ParetoFrontScatterPlot<BinaryVector>> BestResultParameter { get; private set; } 34 36 public IResultDefinition<ParetoFrontScatterPlot<BinaryVector>> BestResult { get { return BestResultParameter; } } 37 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 38 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 35 39 36 public int Length{37 get { return Encoding.Length; }38 set { Encoding.Length= value; }40 public int Dimension { 41 get { return DimensionRefParameter.Value.Value; } 42 set { DimensionRefParameter.Value.Value = value; } 39 43 } 40 44 … … 49 53 : base(original, cloner) { 50 54 BestResultParameter = cloner.Clone(original.BestResultParameter); 55 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 51 56 RegisterEventHandlers(); 52 57 } … … 56 61 EncodingParameter.ReadOnly = true; 57 62 Parameters.Add(BestResultParameter = new ResultParameter<ParetoFrontScatterPlot<BinaryVector>>("Best Pareto Front", "The best Pareto front found.")); 63 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the binary vector problem.", Encoding.LengthParameter)); 58 64 59 65 Operators.Add(new HammingSimilarityCalculator()); … … 86 92 87 93 private void RegisterEventHandlers() { 88 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;94 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 89 95 } 90 96 91 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 97 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 98 DimensionOnChanged(); 99 } 100 101 protected virtual void DimensionOnChanged() { } 92 102 } 93 103 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorProblem.cs
r17522 r17544 21 21 #endregion 22 22 23 using System;24 23 using System.Linq; 25 24 using HEAL.Attic; … … 27 26 using HeuristicLab.Common; 28 27 using HeuristicLab.Core; 28 using HeuristicLab.Data; 29 29 using HeuristicLab.Optimization; 30 30 using HeuristicLab.Optimization.Operators; 31 using HeuristicLab.Parameters; 31 32 32 33 namespace HeuristicLab.Encodings.BinaryVectorEncoding { … … 34 35 public abstract class BinaryVectorProblem : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> { 35 36 [Storable] protected IResultParameter<ISingleObjectiveSolutionContext<BinaryVector>> BestResultParameter { get; private set; } 36 public IResultDefinition<ISingleObjectiveSolutionContext<BinaryVector>> BestResult { get { return BestResultParameter; } } 37 public IResultDefinition<ISingleObjectiveSolutionContext<BinaryVector>> BestResult => BestResultParameter; 38 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 37 39 38 public int Length{40 public int Dimension { 39 41 get { return Encoding.Length; } 40 42 set { Encoding.Length = value; } … … 51 53 : base(original, cloner) { 52 54 BestResultParameter = cloner.Clone(original.BestResultParameter); 55 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 53 56 RegisterEventHandlers(); 54 57 } … … 58 61 EncodingParameter.ReadOnly = true; 59 62 Parameters.Add(BestResultParameter = new ResultParameter<ISingleObjectiveSolutionContext<BinaryVector>>("Best Solution", "The best solution.")); 63 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the binary vector problem.", Encoding.LengthParameter)); 60 64 61 65 Operators.Add(new HammingSimilarityCalculator()); … … 74 78 } 75 79 76 protected override void OnEncodingChanged() {77 base.OnEncodingChanged();78 Parameterize();79 }80 81 80 private void Parameterize() { 82 81 foreach (var similarityCalculator in Operators.OfType<ISolutionSimilarityCalculator>()) { … … 87 86 88 87 private void RegisterEventHandlers() { 89 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 88 Encoding.PropertyChanged += (sender, args) => { 89 if (args.PropertyName == nameof(Encoding.Length)) 90 DimensionOnChanged(); 91 }; 90 92 } 91 93 92 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { }94 protected virtual void DimensionOnChanged() { } 93 95 } 94 96 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorMultiObjectiveProblem.cs
r17522 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 32 using HeuristicLab.Parameters; 31 33 32 34 namespace HeuristicLab.Encodings.IntegerVectorEncoding { … … 35 37 [Storable] protected IResultParameter<ParetoFrontScatterPlot<IntegerVector>> BestResultParameter { get; private set; } 36 38 public IResultDefinition<ParetoFrontScatterPlot<IntegerVector>> BestResult { get { return BestResultParameter; } } 39 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 40 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 37 41 38 public int Length{39 get { return Encoding.Length; }40 set { Encoding.Length= value; }42 public int Dimension { 43 get { return DimensionRefParameter.Value.Value; } 44 set { DimensionRefParameter.Value.Value = value; } 41 45 } 42 46 … … 51 55 : base(original, cloner) { 52 56 BestResultParameter = cloner.Clone(original.BestResultParameter); 57 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 53 58 RegisterEventHandlers(); 54 59 } … … 58 63 EncodingParameter.ReadOnly = true; 59 64 Parameters.Add(BestResultParameter = new ResultParameter<ParetoFrontScatterPlot<IntegerVector>>("Best Pareto Front", "The best Pareto front found.")); 65 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the integer vector problem.", Encoding.LengthParameter)); 60 66 61 67 Operators.Add(new HammingSimilarityCalculator()); … … 88 94 89 95 private void RegisterEventHandlers() { 90 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;96 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 91 97 } 92 98 93 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 99 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 100 DimensionOnChanged(); 101 } 102 103 protected virtual void DimensionOnChanged() { } 94 104 } 95 105 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorProblem.cs
r17522 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 31 32 using HeuristicLab.Optimization.Operators; 33 using HeuristicLab.Parameters; 32 34 33 35 namespace HeuristicLab.Encodings.IntegerVectorEncoding { … … 36 38 [Storable] protected IResultParameter<IntegerVector> BestResultParameter { get; private set; } 37 39 public IResultDefinition<IntegerVector> BestResult { get => BestResultParameter; } 40 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 41 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 42 [Storable] protected ReferenceParameter<IntMatrix> BoundsRefParameter { get; private set; } 43 public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter; 38 44 39 public int Length { 40 get { return Encoding.Length; } 41 set { Encoding.Length = value; } 45 public int Dimension { 46 get { return DimensionRefParameter.Value.Value; } 47 set { DimensionRefParameter.Value.Value = value; } 48 } 49 50 public IntMatrix Bounds { 51 get { return BoundsRefParameter.Value; } 52 set { BoundsRefParameter.Value = value; } 42 53 } 43 54 … … 52 63 : base(original, cloner) { 53 64 BestResultParameter = cloner.Clone(original.BestResultParameter); 65 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 66 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 54 67 RegisterEventHandlers(); 55 68 } … … 59 72 EncodingParameter.ReadOnly = true; 60 73 Parameters.Add(BestResultParameter = new ResultParameter<IntegerVector>("Best Solution", "The best solution.")); 74 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the integer vector problem.", Encoding.LengthParameter)); 75 Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step sizes of the values.", Encoding.BoundsParameter)); 61 76 62 77 Operators.Add(new HammingSimilarityCalculator()); … … 88 103 89 104 private void RegisterEventHandlers() { 90 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 105 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 106 BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged; 91 107 } 92 108 93 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 109 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 110 DimensionOnChanged(); 111 } 112 113 private void BoundsParameter_ValueChanged(object sender, EventArgs e) { 114 BoundsOnChanged(); 115 } 116 117 protected virtual void DimensionOnChanged() { } 118 119 protected virtual void BoundsOnChanged() { } 94 120 } 95 121 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageMultiObjectiveProblem.cs
r17230 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 32 using HeuristicLab.Parameters; 31 33 32 34 namespace HeuristicLab.Encodings.LinearLinkageEncoding { 33 35 [StorableType("ad8b6097-a26b-440c-bfd4-92e5ecf17894")] 34 36 public abstract class LinearLinkageMultiObjectiveProblem : MultiObjectiveProblem<LinearLinkageEncoding, LinearLinkage> { 35 public int Length { 36 get { return Encoding.Length; } 37 set { Encoding.Length = value; } 37 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 38 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 39 40 public int Dimension { 41 get { return DimensionRefParameter.Value.Value; } 42 set { DimensionRefParameter.Value.Value = value; } 38 43 } 39 44 … … 47 52 protected LinearLinkageMultiObjectiveProblem(LinearLinkageMultiObjectiveProblem original, Cloner cloner) 48 53 : base(original, cloner) { 54 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 49 55 RegisterEventHandlers(); 50 56 } … … 53 59 protected LinearLinkageMultiObjectiveProblem(LinearLinkageEncoding encoding) : base(new LinearLinkageEncoding()) { 54 60 EncodingParameter.ReadOnly = true; 61 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the linear linkage problem.", Encoding.LengthParameter)); 62 55 63 56 64 Operators.Add(new HammingSimilarityCalculator()); … … 82 90 83 91 private void RegisterEventHandlers() { 84 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;92 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 85 93 } 86 94 87 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 95 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 96 DimensionOnChanged(); 97 } 98 99 protected virtual void DimensionOnChanged() { } 88 100 } 89 101 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkageProblem.cs
r16950 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 31 32 using HeuristicLab.Optimization.Operators; 33 using HeuristicLab.Parameters; 32 34 33 35 namespace HeuristicLab.Encodings.LinearLinkageEncoding { 34 36 [StorableType("fb4cfc7c-dc7c-4da6-843f-0dad7d3d7981")] 35 37 public abstract class LinearLinkageProblem : SingleObjectiveProblem<LinearLinkageEncoding, LinearLinkage> { 36 public int Length { 37 get { return Encoding.Length; } 38 set { Encoding.Length = value; } 38 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 39 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 40 41 public int Dimension { 42 get { return DimensionRefParameter.Value.Value; } 43 set { DimensionRefParameter.Value.Value = value; } 39 44 } 40 45 … … 48 53 protected LinearLinkageProblem(LinearLinkageProblem original, Cloner cloner) 49 54 : base(original, cloner) { 55 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 50 56 RegisterEventHandlers(); 51 57 } … … 54 60 protected LinearLinkageProblem(LinearLinkageEncoding encoding) : base(encoding) { 55 61 EncodingParameter.ReadOnly = true; 62 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the linear linkage problem.", Encoding.LengthParameter)); 56 63 57 64 Operators.Add(new HammingSimilarityCalculator()); … … 83 90 84 91 private void RegisterEventHandlers() { 85 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged;92 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 86 93 } 87 94 88 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 95 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 96 DimensionOnChanged(); 97 } 98 99 protected virtual void DimensionOnChanged() { } 89 100 } 90 101 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationMultiObjectiveProblem.cs
r17230 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 32 using HeuristicLab.Parameters; 31 33 32 34 namespace HeuristicLab.Encodings.PermutationEncoding { 33 35 [StorableType("7bc5215b-c181-40d0-a758-d7c19a356e18")] 34 36 public abstract class PermutationMultiObjectiveProblem : MultiObjectiveProblem<PermutationEncoding, Permutation> { 35 public int Length { 36 get { return Encoding.Length; } 37 set { Encoding.Length = value; } 38 } 37 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 38 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 39 39 40 public PermutationTypes Type{41 get { return Encoding.Type; }42 set { Encoding.Type = value; }40 public int Dimension { 41 get { return DimensionRefParameter.Value.Value; } 42 set { DimensionRefParameter.Value.Value = value; } 43 43 } 44 44 … … 52 52 protected PermutationMultiObjectiveProblem(PermutationMultiObjectiveProblem original, Cloner cloner) 53 53 : base(original, cloner) { 54 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 54 55 RegisterEventHandlers(); 55 56 } … … 58 59 protected PermutationMultiObjectiveProblem(PermutationEncoding encoding) : base(encoding) { 59 60 EncodingParameter.ReadOnly = true; 61 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the permutation problem.", Encoding.LengthParameter)); 60 62 61 63 Operators.Add(new HammingSimilarityCalculator()); … … 87 89 88 90 private void RegisterEventHandlers() { 89 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 90 Encoding.PermutationTypeParameter.Value.ValueChanged += TypeParameter_ValueChanged; 91 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 91 92 } 92 93 93 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 94 protected virtual void TypeParameter_ValueChanged(object sender, EventArgs e) { } 94 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 95 DimensionOnChanged(); 96 } 97 98 protected virtual void DimensionOnChanged() { } 95 99 } 96 100 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationProblem.cs
r16950 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 31 32 using HeuristicLab.Optimization.Operators; 33 using HeuristicLab.Parameters; 32 34 33 35 namespace HeuristicLab.Encodings.PermutationEncoding { 34 36 [StorableType("aceff7a2-0666-4055-b698-6ea3628713b6")] 35 37 public abstract class PermutationProblem : SingleObjectiveProblem<PermutationEncoding, Permutation> { 36 public int Length { 37 get { return Encoding.Length; } 38 set { Encoding.Length = value; } 39 } 38 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 39 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 40 40 41 public PermutationTypes Type{42 get { return Encoding.Type; }43 set { Encoding.Type = value; }41 public int Dimension { 42 get { return DimensionRefParameter.Value.Value; } 43 set { DimensionRefParameter.Value.Value = value; } 44 44 } 45 45 … … 53 53 protected PermutationProblem(PermutationProblem original, Cloner cloner) 54 54 : base(original, cloner) { 55 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 55 56 RegisterEventHandlers(); 56 57 } … … 59 60 protected PermutationProblem(PermutationEncoding encoding) : base(encoding) { 60 61 EncodingParameter.ReadOnly = true; 62 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the permutation problem.", Encoding.LengthParameter)); 61 63 62 64 Operators.Add(new HammingSimilarityCalculator()); … … 87 89 88 90 private void RegisterEventHandlers() { 89 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 90 Encoding.PermutationTypeParameter.Value.ValueChanged += TypeParameter_ValueChanged; 91 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 91 92 } 92 93 93 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 94 protected virtual void TypeParameter_ValueChanged(object sender, EventArgs e) { } 94 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 95 DimensionOnChanged(); 96 } 97 98 protected virtual void DimensionOnChanged() { } 95 99 } 96 100 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorMultiObjectiveProblem.cs
r17230 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 32 using HeuristicLab.Parameters; 31 33 32 34 namespace HeuristicLab.Encodings.RealVectorEncoding { 33 35 [StorableType("135697c1-1b2b-46b6-a518-1c6efae09475")] 34 36 public abstract class RealVectorMultiObjectiveProblem : MultiObjectiveProblem<RealVectorEncoding, RealVector> { 35 public int Length { 36 get { return Encoding.Length; } 37 set { Encoding.Length = value; } 37 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 38 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 39 [Storable] protected ReferenceParameter<DoubleMatrix> BoundsRefParameter { get; private set; } 40 public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter; 41 42 public int Dimension { 43 get { return DimensionRefParameter.Value.Value; } 44 set { DimensionRefParameter.Value.Value = value; } 45 } 46 47 public DoubleMatrix Bounds { 48 get { return BoundsRefParameter.Value; } 49 set { BoundsParameter.Value = value; } 38 50 } 39 51 … … 47 59 protected RealVectorMultiObjectiveProblem(RealVectorMultiObjectiveProblem original, Cloner cloner) 48 60 : base(original, cloner) { 61 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 62 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 49 63 RegisterEventHandlers(); 50 64 } … … 53 67 protected RealVectorMultiObjectiveProblem(RealVectorEncoding encoding) : base(encoding) { 54 68 EncodingParameter.ReadOnly = true; 69 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the real vector problem.", Encoding.LengthParameter)); 70 Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the values.", Encoding.BoundsParameter)); 71 55 72 56 73 Operators.Add(new HammingSimilarityCalculator()); … … 82 99 83 100 private void RegisterEventHandlers() { 84 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 101 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 102 BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged; 85 103 } 86 104 87 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 105 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 106 DimensionOnChanged(); 107 } 108 109 private void BoundsParameter_ValueChanged(object sender, EventArgs e) { 110 BoundsOnChanged(); 111 } 112 113 protected virtual void DimensionOnChanged() { } 114 115 protected virtual void BoundsOnChanged() { } 88 116 } 89 117 } -
branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorProblem.cs
r16950 r17544 28 28 using HeuristicLab.Common; 29 29 using HeuristicLab.Core; 30 using HeuristicLab.Data; 30 31 using HeuristicLab.Optimization; 31 32 using HeuristicLab.Optimization.Operators; 33 using HeuristicLab.Parameters; 32 34 33 35 namespace HeuristicLab.Encodings.RealVectorEncoding { 34 36 [StorableType("7860a955-af16-459a-9cd8-51667e06d38e")] 35 37 public abstract class RealVectorProblem : SingleObjectiveProblem<RealVectorEncoding, RealVector> { 36 public int Length { 37 get { return Encoding.Length; } 38 set { Encoding.Length = value; } 38 [Storable] protected ReferenceParameter<IntValue> DimensionRefParameter { get; private set; } 39 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 40 [Storable] protected ReferenceParameter<DoubleMatrix> BoundsRefParameter { get; private set; } 41 public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter; 42 43 public int Dimension { 44 get { return DimensionRefParameter.Value.Value; } 45 set { DimensionRefParameter.Value.Value = value; } 46 } 47 48 public DoubleMatrix Bounds { 49 get { return BoundsRefParameter.Value; } 50 set { BoundsParameter.Value = value; } 39 51 } 40 52 … … 48 60 protected RealVectorProblem(RealVectorProblem original, Cloner cloner) 49 61 : base(original, cloner) { 62 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 63 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 50 64 RegisterEventHandlers(); 51 65 } … … 54 68 protected RealVectorProblem(RealVectorEncoding encoding) : base(encoding) { 55 69 EncodingParameter.ReadOnly = true; 70 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the real vector problem.", Encoding.LengthParameter)); 71 Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the values.", Encoding.BoundsParameter)); 56 72 57 73 Operators.Add(new HammingSimilarityCalculator()); … … 83 99 84 100 private void RegisterEventHandlers() { 85 Encoding.LengthParameter.Value.ValueChanged += LengthParameter_ValueChanged; 101 DimensionRefParameter.Value.ValueChanged += DimensionParameter_Value_ValueChanged; 102 BoundsRefParameter.ValueChanged += BoundsParameter_ValueChanged; 86 103 } 87 104 88 protected virtual void LengthParameter_ValueChanged(object sender, EventArgs e) { } 105 private void DimensionParameter_Value_ValueChanged(object sender, EventArgs e) { 106 DimensionOnChanged(); 107 } 108 109 private void BoundsParameter_ValueChanged(object sender, EventArgs e) { 110 BoundsOnChanged(); 111 } 112 113 protected virtual void DimensionOnChanged() { } 114 115 protected virtual void BoundsOnChanged() { } 89 116 } 90 117 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveStepTrapProblem.cs
r17226 r17544 22 22 #endregion 23 23 24 using System; 24 25 using HEAL.Attic; 25 26 using HeuristicLab.Common; … … 34 35 [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 230)] 35 36 public class DeceptiveStepTrapProblem : DeceptiveTrapProblem { 36 [StorableConstructor] 37 protected DeceptiveStepTrapProblem(StorableConstructorFlag _) : base(_) { } 38 protected DeceptiveStepTrapProblem(DeceptiveStepTrapProblem original, Cloner cloner) 39 : base(original, cloner) { 40 RegisterParameterEvents(); 41 } 42 public override IDeepCloneable Clone(Cloner cloner) { 43 return new DeceptiveStepTrapProblem(this, cloner); 44 } 45 46 private const string StepSizeParameterName = "Step Size"; 47 48 public IFixedValueParameter<IntValue> StepSizeParameter { 49 get { return (IFixedValueParameter<IntValue>)Parameters[StepSizeParameterName]; } 50 } 37 [Storable] private int offset = -1; 38 [Storable] public IFixedValueParameter<IntValue> StepSizeParameter { get; private set; } 51 39 52 40 public int StepSize { … … 56 44 57 45 public DeceptiveStepTrapProblem() : base() { 58 Parameters.Add(new FixedValueParameter<IntValue>(StepSizeParameterName, "", new IntValue(2))); 46 Parameters.Add(StepSizeParameter = new FixedValueParameter<IntValue>("Step Size", "", new IntValue(2))); 47 offset = (TrapSize - StepSize) % StepSize; 48 59 49 RegisterParameterEvents(); 60 50 } 51 52 protected override int TrapMaximum { 53 get { return (offset + TrapSize) / StepSize; } 54 } 55 56 protected override int Score(BinaryVector individual, int trapIndex, int trapSize) { 57 int partial = base.Score(individual, trapIndex, trapSize); 58 // introduce plateaus using integer division 59 return (offset + partial) / StepSize; 60 } 61 62 [StorableConstructor] 63 protected DeceptiveStepTrapProblem(StorableConstructorFlag _) : base(_) { } 61 64 62 65 [StorableHook(HookType.AfterDeserialization)] … … 64 67 RegisterParameterEvents(); 65 68 } 69 protected DeceptiveStepTrapProblem(DeceptiveStepTrapProblem original, Cloner cloner) 70 : base(original, cloner) { 71 offset = original.offset; 72 StepSizeParameter = cloner.Clone(original.StepSizeParameter); 73 74 RegisterParameterEvents(); 75 } 76 public override IDeepCloneable Clone(Cloner cloner) { 77 return new DeceptiveStepTrapProblem(this, cloner); 78 } 66 79 67 80 private void RegisterParameterEvents() { 68 TrapSizeParameter.Value.ValueChanged += (o, e) => { offset = -1; }; 69 StepSizeParameter.Value.ValueChanged += (o, e) => { offset = -1; }; 81 StepSizeParameter.Value.ValueChanged += StepSizeOnChanged; 70 82 } 71 83 72 73 private int offset = -1; 74 private int Offset { 75 get { 76 if (offset == -1) offset = (TrapSize - StepSize) % StepSize; 77 return offset; 78 } 84 protected override void TrapSizeOnChanged(object sender, EventArgs e) { 85 base.TrapSizeOnChanged(sender, e); 86 offset = (TrapSize - StepSize) % StepSize; 79 87 } 80 88 81 protected override int TrapMaximum { 82 get { return (Offset + TrapSize) / StepSize; } 83 } 84 85 protected override int Score(BinaryVector individual, int trapIndex, int trapSize) { 86 int partial = base.Score(individual, trapIndex, trapSize); 87 // introduce plateaus using integer division 88 return (Offset + partial) / StepSize; 89 private void StepSizeOnChanged(object sender, EventArgs e) { 90 offset = (TrapSize - StepSize) % StepSize; 89 91 } 90 92 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/DeceptiveTrapProblem.cs
r17382 r17544 37 37 [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 230)] 38 38 public class DeceptiveTrapProblem : BinaryVectorProblem { 39 [StorableConstructor] 40 protected DeceptiveTrapProblem(StorableConstructorFlag _) : base(_) { } 41 protected DeceptiveTrapProblem(DeceptiveTrapProblem original, Cloner cloner) 42 : base(original, cloner) { 43 } 44 public override IDeepCloneable Clone(Cloner cloner) { 45 return new DeceptiveTrapProblem(this, cloner); 46 } 47 48 private const string TrapSizeParameterName = "Trap Size"; 49 50 public IFixedValueParameter<IntValue> TrapSizeParameter { 51 get { return (IFixedValueParameter<IntValue>)Parameters[TrapSizeParameterName]; } 52 } 39 [Storable] public IFixedValueParameter<IntValue> TrapSizeParameter { get; private set; } 40 [Storable] public IFixedValueParameter<IntValue> NumberOfTrapsParameter { get; private set; } 53 41 54 42 public int TrapSize { 55 43 get { return TrapSizeParameter.Value.Value; } 56 44 set { TrapSizeParameter.Value.Value = value; } 45 } 46 47 public int NumberOfTraps { 48 get { return NumberOfTrapsParameter.Value.Value; } 49 set { NumberOfTrapsParameter.Value.Value = value; } 57 50 } 58 51 … … 63 56 public DeceptiveTrapProblem() : base() { 64 57 Maximization = true; 65 Parameters.Add(new FixedValueParameter<IntValue>(TrapSizeParameterName, "", new IntValue(7))); 66 Encoding.Length = 49; 58 Parameters.Add(TrapSizeParameter = new FixedValueParameter<IntValue>("Trap Size", "", new IntValue(7))); 59 Parameters.Add(NumberOfTrapsParameter = new FixedValueParameter<IntValue>("Number of Traps", "", new IntValue(7))); 60 Dimension = TrapSize * NumberOfTraps; 61 62 RegisterEventHandlers(); 67 63 } 68 64 … … 83 79 84 80 public override ISingleObjectiveEvaluationResult Evaluate(BinaryVector individual, IRandom random, CancellationToken cancellationToken) { 85 if (individual.Length != Length) throw new ArgumentException("The individual has not the correct length.");81 if (individual.Length != Dimension) throw new ArgumentException("The individual has not the correct length."); 86 82 int total = 0; 87 83 var trapSize = TrapSize; … … 92 88 return new SingleObjectiveEvaluationResult(quality); 93 89 } 90 91 [StorableConstructor] 92 protected DeceptiveTrapProblem(StorableConstructorFlag _) : base(_) { } 93 [StorableHook(HookType.AfterDeserialization)] 94 private void AfterDeserialization() { 95 RegisterEventHandlers(); 96 } 97 protected DeceptiveTrapProblem(DeceptiveTrapProblem original, Cloner cloner) 98 : base(original, cloner) { 99 TrapSizeParameter = cloner.Clone(original.TrapSizeParameter); 100 NumberOfTrapsParameter = cloner.Clone(original.NumberOfTrapsParameter); 101 102 RegisterEventHandlers(); 103 } 104 public override IDeepCloneable Clone(Cloner cloner) { 105 return new DeceptiveTrapProblem(this, cloner); 106 } 107 108 private void RegisterEventHandlers() { 109 TrapSizeParameter.Value.ValueChanged += TrapSizeOnChanged; 110 NumberOfTrapsParameter.Value.ValueChanged += NumberOfTrapsOnChanged; 111 } 112 113 protected virtual void TrapSizeOnChanged(object sender, EventArgs e) { 114 Dimension = TrapSize * NumberOfTraps; 115 } 116 117 private void NumberOfTrapsOnChanged(object sender, EventArgs e) { 118 Dimension = TrapSize * NumberOfTraps; 119 } 94 120 } 95 121 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/HIFFProblem.cs
r17382 r17544 27 27 using HeuristicLab.Common; 28 28 using HeuristicLab.Core; 29 using HeuristicLab.Data; 29 30 using HeuristicLab.Encodings.BinaryVectorEncoding; 30 31 using HeuristicLab.Optimization; … … 35 36 [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 220)] 36 37 public class HIFFProblem : BinaryVectorProblem { 37 [StorableConstructor]38 protected HIFFProblem(StorableConstructorFlag _) : base(_) { }39 protected HIFFProblem(HIFFProblem original, Cloner cloner)40 : base(original, cloner) {41 }42 public override IDeepCloneable Clone(Cloner cloner) {43 return new HIFFProblem(this, cloner);44 }45 38 46 39 public HIFFProblem() : base() { 47 40 Maximization = true; 48 Encoding.Length = 64;41 DimensionRefParameter.ForceValue(new IntValue(64, @readonly: false)); 49 42 } 43 50 44 // In the GECCO paper, Section 4.1 51 45 public override ISingleObjectiveEvaluationResult Evaluate(BinaryVector individual, IRandom random, CancellationToken cancellationToken) { … … 87 81 return new SingleObjectiveEvaluationResult(quality); 88 82 } 83 84 [StorableConstructor] 85 protected HIFFProblem(StorableConstructorFlag _) : base(_) { } 86 protected HIFFProblem(HIFFProblem original, Cloner cloner) 87 : base(original, cloner) { 88 } 89 public override IDeepCloneable Clone(Cloner cloner) { 90 return new HIFFProblem(this, cloner); 91 } 89 92 } 90 93 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/OneMaxProblem.cs
r17382 r17544 20 20 #endregion 21 21 22 using System;23 22 using System.Linq; 24 23 using System.Threading; … … 26 25 using HeuristicLab.Common; 27 26 using HeuristicLab.Core; 27 using HeuristicLab.Data; 28 28 using HeuristicLab.Encodings.BinaryVectorEncoding; 29 29 using HeuristicLab.Optimization; … … 37 37 public OneMaxProblem() : base() { 38 38 Maximization = true; 39 Encoding.Length = 10; 40 BestKnownQuality = Encoding.Length; 41 } 42 43 [StorableConstructor] 44 protected OneMaxProblem(StorableConstructorFlag _) : base(_) { } 45 46 protected OneMaxProblem(OneMaxProblem original, Cloner cloner) : base(original, cloner) { } 47 public override IDeepCloneable Clone(Cloner cloner) { 48 return new OneMaxProblem(this, cloner); 39 DimensionRefParameter.ForceValue(new IntValue(10, @readonly: false)); 40 BestKnownQuality = Dimension; 49 41 } 50 42 … … 54 46 } 55 47 56 protected override void LengthParameter_ValueChanged(object sender, EventArgs e) { 57 base.LengthParameter_ValueChanged(sender, e); 58 BestKnownQuality = Length; 48 [StorableConstructor] 49 protected OneMaxProblem(StorableConstructorFlag _) : base(_) { } 50 protected OneMaxProblem(OneMaxProblem original, Cloner cloner) : base(original, cloner) { } 51 public override IDeepCloneable Clone(Cloner cloner) { 52 return new OneMaxProblem(this, cloner); 53 } 54 55 protected override void DimensionOnChanged() { 56 base.DimensionOnChanged(); 57 BestKnownQuality = Dimension; 59 58 } 60 59 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblemInstances.cs
r16874 r17544 41 41 [StorableType("4ea0ded8-4451-4011-b88e-4d0680721b01")] 42 42 public sealed class SingleObjectiveBinaryVectorExternalEvaluationProblem : ExternalEvaluationProblem<BinaryVectorEncoding, BinaryVector> { 43 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 44 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 45 46 public int Dimension { 47 get => Encoding.Length; 48 set => Encoding.Length = value; 49 } 43 50 44 51 [StorableConstructor] 45 52 private SingleObjectiveBinaryVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 46 private SingleObjectiveBinaryVectorExternalEvaluationProblem(SingleObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 53 private SingleObjectiveBinaryVectorExternalEvaluationProblem(SingleObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) 54 : base(original, cloner) { 55 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 56 } 47 57 48 58 public SingleObjectiveBinaryVectorExternalEvaluationProblem() 49 59 : base(new BinaryVectorEncoding()) { 50 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 51 Parameters.Add(lengthParameter); 52 Encoding.LengthParameter = lengthParameter; 60 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 61 DimensionRefParameter.ForceValue(new IntValue(Dimension, @readonly: false)); 53 62 // TODO: Add and parameterize additional operators, 54 63 } … … 64 73 [StorableType("46465e8c-11d8-4d02-8c45-de41a08db7fa")] 65 74 public sealed class SingleObjectiveIntegerVectorExternalEvaluationProblem : ExternalEvaluationProblem<IntegerVectorEncoding, IntegerVector> { 75 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 76 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 77 [Storable] private ReferenceParameter<IntMatrix> BoundsRefParameter; 78 public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter; 79 80 public int Dimension { 81 get => DimensionRefParameter.Value.Value; 82 set => DimensionRefParameter.Value.Value = value; 83 } 84 85 public IntMatrix Bounds { 86 get => BoundsRefParameter.Value; 87 set => BoundsRefParameter.Value = value; 88 } 66 89 67 90 [StorableConstructor] 68 91 private SingleObjectiveIntegerVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 69 private SingleObjectiveIntegerVectorExternalEvaluationProblem(SingleObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 92 private SingleObjectiveIntegerVectorExternalEvaluationProblem(SingleObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) 93 : base(original, cloner) { 94 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 95 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 96 } 70 97 71 98 public SingleObjectiveIntegerVectorExternalEvaluationProblem() 72 99 : base(new IntegerVectorEncoding()) { 73 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 74 Parameters.Add(lengthParameter); 75 Encoding.LengthParameter = lengthParameter; 100 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 101 Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step size of the elements.", Encoding.BoundsParameter)); 76 102 // TODO: Add and parameterize additional operators, 77 103 } … … 87 113 [StorableType("637f091f-6601-494e-bafb-2a8ea474210c")] 88 114 public sealed class SingleObjectiveRealVectorExternalEvaluationProblem : ExternalEvaluationProblem<RealVectorEncoding, RealVector> { 115 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 116 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 117 [Storable] private ReferenceParameter<DoubleMatrix> BoundsRefParameter; 118 public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter; 119 120 public int Dimension { 121 get => DimensionRefParameter.Value.Value; 122 set => DimensionRefParameter.Value.Value = value; 123 } 124 125 public DoubleMatrix Bounds { 126 get => BoundsRefParameter.Value; 127 set => BoundsRefParameter.Value = value; 128 } 89 129 90 130 [StorableConstructor] 91 131 private SingleObjectiveRealVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 92 private SingleObjectiveRealVectorExternalEvaluationProblem(SingleObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 132 private SingleObjectiveRealVectorExternalEvaluationProblem(SingleObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) 133 : base(original, cloner) { 134 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 135 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 136 } 93 137 94 138 public SingleObjectiveRealVectorExternalEvaluationProblem() 95 139 : base(new RealVectorEncoding()) { 96 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 97 Parameters.Add(lengthParameter); 98 Encoding.LengthParameter = lengthParameter; 140 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 141 Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the elements.", Encoding.BoundsParameter)); 99 142 // TODO: Add and parameterize additional operators, 100 143 } … … 110 153 [StorableType("ad9d45f8-b97e-49a7-b3d2-487d9a2cbdf9")] 111 154 public sealed class SingleObjectivePermutationExternalEvaluationProblem : ExternalEvaluationProblem<PermutationEncoding, Permutation> { 155 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 156 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 157 158 public int Dimension { 159 get => DimensionRefParameter.Value.Value; 160 set => DimensionRefParameter.Value.Value = value; 161 } 112 162 113 163 [StorableConstructor] 114 164 private SingleObjectivePermutationExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 115 private SingleObjectivePermutationExternalEvaluationProblem(SingleObjectivePermutationExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 165 private SingleObjectivePermutationExternalEvaluationProblem(SingleObjectivePermutationExternalEvaluationProblem original, Cloner cloner) 166 : base(original, cloner) { 167 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 168 } 116 169 117 170 public SingleObjectivePermutationExternalEvaluationProblem() 118 171 : base(new PermutationEncoding()) { 119 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the permutation.", new IntValue(10)); 120 Parameters.Add(lengthParameter); 121 Encoding.LengthParameter = lengthParameter; 172 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 122 173 // TODO: Add and parameterize additional operators, 123 174 } … … 140 191 public SingleObjectiveSymbolicExpressionTreeExternalEvaluationProblem() 141 192 : base(new SymbolicExpressionTreeEncoding()) { 193 // TODO: Change to ReferenceParameter 142 194 var lengthParameter = new FixedValueParameter<IntValue>("TreeLength", "The total amount of nodes.", new IntValue(50)); 143 195 Parameters.Add(lengthParameter); … … 159 211 [StorableType("945a35d9-89a8-4423-9ea0-21829ac68887")] 160 212 public sealed class SingleObjectiveLinearLinkageExternalEvaluationProblem : ExternalEvaluationProblem<LinearLinkageEncoding, LinearLinkage> { 213 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 214 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 215 216 public int Dimension { 217 get => DimensionRefParameter.Value.Value; 218 set => DimensionRefParameter.Value.Value = value; 219 } 161 220 162 221 [StorableConstructor] 163 222 private SingleObjectiveLinearLinkageExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 164 private SingleObjectiveLinearLinkageExternalEvaluationProblem(SingleObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 223 private SingleObjectiveLinearLinkageExternalEvaluationProblem(SingleObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) 224 : base(original, cloner) { 225 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 226 } 165 227 166 228 public SingleObjectiveLinearLinkageExternalEvaluationProblem() 167 229 : base(new LinearLinkageEncoding()) { 168 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 169 Parameters.Add(lengthParameter); 170 Encoding.LengthParameter = lengthParameter; 230 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 171 231 // TODO: Add and parameterize additional operators, 172 232 } … … 199 259 [StorableType("f14c7e88-b74d-4cad-ae55-83daf7b4c288")] 200 260 public sealed class MultiObjectiveBinaryVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<BinaryVectorEncoding, BinaryVector> { 261 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 262 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 263 264 public int Dimension { 265 get => Encoding.Length; 266 set => Encoding.Length = value; 267 } 201 268 202 269 [StorableConstructor] 203 270 private MultiObjectiveBinaryVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 204 private MultiObjectiveBinaryVectorExternalEvaluationProblem(MultiObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 271 private MultiObjectiveBinaryVectorExternalEvaluationProblem(MultiObjectiveBinaryVectorExternalEvaluationProblem original, Cloner cloner) 272 : base(original, cloner) { 273 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 274 } 205 275 206 276 public MultiObjectiveBinaryVectorExternalEvaluationProblem() 207 277 : base(new BinaryVectorEncoding()) { 208 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 209 Parameters.Add(lengthParameter); 210 Encoding.LengthParameter = lengthParameter; 278 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 279 DimensionRefParameter.ForceValue(new IntValue(Dimension, @readonly: false)); 211 280 // TODO: Add and parameterize additional operators, 212 281 } … … 222 291 [StorableType("90a82c2f-6c37-4ffd-8495-bee278c583d3")] 223 292 public sealed class MultiObjectiveIntegerVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<IntegerVectorEncoding, IntegerVector> { 293 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 294 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 295 [Storable] private ReferenceParameter<IntMatrix> BoundsRefParameter; 296 public IValueParameter<IntMatrix> BoundsParameter => BoundsRefParameter; 297 298 public int Dimension { 299 get => DimensionRefParameter.Value.Value; 300 set => DimensionRefParameter.Value.Value = value; 301 } 302 303 public IntMatrix Bounds { 304 get => BoundsRefParameter.Value; 305 set => BoundsRefParameter.Value = value; 306 } 224 307 225 308 [StorableConstructor] 226 309 private MultiObjectiveIntegerVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 227 private MultiObjectiveIntegerVectorExternalEvaluationProblem(MultiObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 310 private MultiObjectiveIntegerVectorExternalEvaluationProblem(MultiObjectiveIntegerVectorExternalEvaluationProblem original, Cloner cloner) 311 : base(original, cloner) { 312 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 313 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 314 } 228 315 229 316 public MultiObjectiveIntegerVectorExternalEvaluationProblem() 230 317 : base(new IntegerVectorEncoding()) { 231 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 232 Parameters.Add(lengthParameter); 233 Encoding.LengthParameter = lengthParameter; 318 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 319 Parameters.Add(BoundsRefParameter = new ReferenceParameter<IntMatrix>("Bounds", "The bounding box and step size of the elements.", Encoding.BoundsParameter)); 234 320 // TODO: Add and parameterize additional operators, 235 321 } … … 245 331 [StorableType("38e1d068-d569-48c5-bad6-cbdd685b7c6b")] 246 332 public sealed class MultiObjectiveRealVectorExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<RealVectorEncoding, RealVector> { 333 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 334 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 335 [Storable] private ReferenceParameter<DoubleMatrix> BoundsRefParameter; 336 public IValueParameter<DoubleMatrix> BoundsParameter => BoundsRefParameter; 337 338 public int Dimension { 339 get => DimensionRefParameter.Value.Value; 340 set => DimensionRefParameter.Value.Value = value; 341 } 342 343 public DoubleMatrix Bounds { 344 get => BoundsRefParameter.Value; 345 set => BoundsRefParameter.Value = value; 346 } 247 347 248 348 [StorableConstructor] 249 349 private MultiObjectiveRealVectorExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 250 private MultiObjectiveRealVectorExternalEvaluationProblem(MultiObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 350 private MultiObjectiveRealVectorExternalEvaluationProblem(MultiObjectiveRealVectorExternalEvaluationProblem original, Cloner cloner) 351 : base(original, cloner) { 352 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 353 BoundsRefParameter = cloner.Clone(original.BoundsRefParameter); 354 } 251 355 252 356 public MultiObjectiveRealVectorExternalEvaluationProblem() 253 357 : base(new RealVectorEncoding()) { 254 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 255 Parameters.Add(lengthParameter); 256 Encoding.LengthParameter = lengthParameter; 358 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 359 Parameters.Add(BoundsRefParameter = new ReferenceParameter<DoubleMatrix>("Bounds", "The bounding box of the elements.", Encoding.BoundsParameter)); 257 360 // TODO: Add and parameterize additional operators, 258 361 } … … 268 371 [StorableType("f1b265b0-ac7c-4c36-b346-5b3f2c37694b")] 269 372 public sealed class MultiObjectivePermutationExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<PermutationEncoding, Permutation> { 373 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 374 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 375 376 public int Dimension { 377 get => DimensionRefParameter.Value.Value; 378 set => DimensionRefParameter.Value.Value = value; 379 } 270 380 271 381 [StorableConstructor] 272 382 private MultiObjectivePermutationExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 273 private MultiObjectivePermutationExternalEvaluationProblem(MultiObjectivePermutationExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 383 private MultiObjectivePermutationExternalEvaluationProblem(MultiObjectivePermutationExternalEvaluationProblem original, Cloner cloner) 384 : base(original, cloner) { 385 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 386 } 274 387 275 388 public MultiObjectivePermutationExternalEvaluationProblem() 276 389 : base(new PermutationEncoding()) { 277 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the permutation.", new IntValue(10)); 278 Parameters.Add(lengthParameter); 279 Encoding.LengthParameter = lengthParameter; 390 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 280 391 // TODO: Add and parameterize additional operators, 281 392 } … … 298 409 public MultiObjectiveSymbolicExpressionTreeExternalEvaluationProblem() 299 410 : base(new SymbolicExpressionTreeEncoding()) { 411 // TODO: Change to ReferenceParameter 300 412 var lengthParameter = new FixedValueParameter<IntValue>("TreeLength", "The total amount of nodes.", new IntValue(50)); 301 413 Parameters.Add(lengthParameter); … … 317 429 [StorableType("ed0c1129-651d-465f-87b0-f412f3e3b3d1")] 318 430 public sealed class MultiObjectiveLinearLinkageExternalEvaluationProblem : MultiObjectiveExternalEvaluationProblem<LinearLinkageEncoding, LinearLinkage> { 431 [Storable] private ReferenceParameter<IntValue> DimensionRefParameter; 432 public IValueParameter<IntValue> DimensionParameter => DimensionRefParameter; 433 434 public int Dimension { 435 get => DimensionRefParameter.Value.Value; 436 set => DimensionRefParameter.Value.Value = value; 437 } 319 438 320 439 [StorableConstructor] 321 440 private MultiObjectiveLinearLinkageExternalEvaluationProblem(StorableConstructorFlag _) : base(_) { } 322 private MultiObjectiveLinearLinkageExternalEvaluationProblem(MultiObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) : base(original, cloner) { } 441 private MultiObjectiveLinearLinkageExternalEvaluationProblem(MultiObjectiveLinearLinkageExternalEvaluationProblem original, Cloner cloner) 442 : base(original, cloner) { 443 DimensionRefParameter = cloner.Clone(original.DimensionRefParameter); 444 } 323 445 324 446 public MultiObjectiveLinearLinkageExternalEvaluationProblem() 325 447 : base(new LinearLinkageEncoding()) { 326 var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the vector.", new IntValue(10)); 327 Parameters.Add(lengthParameter); 328 Encoding.LengthParameter = lengthParameter; 448 Parameters.Add(DimensionRefParameter = new ReferenceParameter<IntValue>("Dimension", "The dimension of the vector.", Encoding.LengthParameter)); 329 449 // TODO: Add and parameterize additional operators, 330 450 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.GraphColoring/3.3/GraphColoringProblem.cs
r17382 r17544 83 83 imat[i, 1] = defaultInstance[i].Item2 - 1; 84 84 } 85 Encoding.Length= defaultInstanceNodes;85 Dimension = defaultInstanceNodes; 86 86 AdjacencyListParameter.Value = imat; 87 87 BestKnownQualityParameter.Value = null; … … 121 121 if (FitnessFunction == FitnessFunction.Prioritized 122 122 && BestKnownColorsParameter.Value != null 123 && Encoding.Length> 0) {124 var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10( Encoding.Length)));123 && Dimension > 0) { 124 var mag = Math.Pow(10, -(int)Math.Ceiling(Math.Log10(Dimension))); 125 125 // the value is e.g. 0.051 for 0 conflicts with 51 colors (and less than 1000 nodes) 126 126 BestKnownQuality = BestKnownColorsParameter.Value.Value * mag; … … 247 247 248 248 public void Load(GCPData data) { 249 Encoding.Length= data.Nodes;249 Dimension = data.Nodes; 250 250 AdjacencyListParameter.Value = new IntMatrix(data.Adjacencies); 251 251 if (data.BestKnownColoring != null) { … … 279 279 instance.Name = Name; 280 280 instance.Description = Description; 281 instance.Nodes = Encoding.Length;281 instance.Nodes = Dimension; 282 282 var adjList = AdjacencyListParameter.Value; 283 283 instance.Adjacencies = new int[adjList.Rows, 2]; -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs
r17382 r17544 91 91 Parameters.Add(new OptionalValueParameter<BinaryVector>("BestKnownSolution", "The best known solution of this Knapsack instance.")); 92 92 93 Dimension = Weights.Length; 93 94 InitializeRandomKnapsackInstance(); 94 95 … … 125 126 ValuesParameter.ValueChanged += ValuesParameter_ValueChanged; 126 127 ValuesParameter.Value.Reset += ValuesValue_Reset; 127 // TODO: There is no even to detect if the parameter itself was changed128 Encoding.LengthParameter.ValueChanged += Encoding_LengthParameter_ValueChanged;129 128 } 130 129 … … 144 143 Parameterize(); 145 144 } 145 protected override void DimensionOnChanged() { 146 base.DimensionOnChanged(); 147 if (Weights.Length != Dimension) { 148 ((IStringConvertibleArray)WeightsParameter.Value).Length = Dimension; 149 } 150 if (Values.Length != Dimension) { 151 ((IStringConvertibleArray)ValuesParameter.Value).Length = Dimension; 152 } 153 Parameterize(); 154 } 146 155 private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) { 147 156 Parameterize(); … … 157 166 if (WeightsParameter.Value != null && ValuesParameter.Value != null) { 158 167 ((IStringConvertibleArray)ValuesParameter.Value).Length = Weights.Length; 159 Encoding.Length= Weights.Length;168 Dimension = Weights.Length; 160 169 } 161 170 Parameterize(); … … 168 177 if (WeightsParameter.Value != null && ValuesParameter.Value != null) { 169 178 ((IStringConvertibleArray)WeightsParameter.Value).Length = Values.Length; 170 Encoding.Length = Values.Length; 171 } 172 Parameterize(); 173 } 174 private void Encoding_LengthParameter_ValueChanged(object sender, EventArgs e) { 175 if (Weights.Length != Encoding.Length) { 176 ((IStringConvertibleArray)WeightsParameter.Value).Length = Encoding.Length; 177 } 178 if (Values.Length != Encoding.Length) { 179 ((IStringConvertibleArray)ValuesParameter.Value).Length = Encoding.Length; 179 Dimension = Values.Length; 180 180 } 181 181 Parameterize(); … … 271 271 272 272 KnapsackCapacity = (int)Math.Round(0.7 * totalWeight); 273 Dimension = Weights.Length; 273 274 } 274 275 } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.LinearAssignment/3.3/LinearAssignmentProblem.cs
r17530 r17544 243 243 244 244 private void Parameterize() { 245 if (Costs.Rows != Dimension) Dimension = Costs.Rows; 245 246 foreach (var similarityCalculator in Operators.OfType<ISolutionSimilarityCalculator>()) { 246 247 similarityCalculator.SolutionVariableName = Encoding.Name; -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.NK/3.3/NKLandscape.cs
r17382 r17544 232 232 } 233 233 234 protected override void LengthParameter_ValueChanged(object sender, EventArgs e) { 235 NrOfFitnessComponentsParameter.Value = new IntValue(Length); 234 protected override void DimensionOnChanged() { 235 base.DimensionOnChanged(); 236 NrOfFitnessComponentsParameter.Value = new IntValue(Dimension); 236 237 } 237 238 … … 259 260 if (InteractionInitializer != null) 260 261 GeneInteractionsParameter.Value = InteractionInitializer.InitializeInterations( 261 Length,262 Dimension, 262 263 NrOfFitnessComponents.Value, 263 264 NrOfInteractions.Value, random); -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.Orienteering/3.3/OrienteeringProblem.cs
r17533 r17544 20 20 #endregion 21 21 22 using System; 22 23 using System.Collections.Generic; 23 24 using System.IO; … … 75 76 Parameters.Add(BestOrienteeringSolutionParameter = new ResultParameter<OrienteeringSolution>("Best Orienteering Solution", "The best so far solution found.")); 76 77 Maximization = true; 78 Dimension = OrienteeringProblemData.Cities; 77 79 78 80 InitializeOperators(); … … 145 147 } 146 148 147 protected override void OnEncodingChanged() { 148 base.OnEncodingChanged(); 149 ParameterizeOperators(); 149 private void RegisterEventHandlers() { 150 OrienteeringProblemDataParameter.ValueChanged += OrienteeringProblemDataParameterOnValueChanged; 151 } 152 153 private void OrienteeringProblemDataParameterOnValueChanged(object sender, EventArgs e) { 154 Dimension = OrienteeringProblemData.Cities; 150 155 } 151 156 … … 153 158 base.OnEvaluatorChanged(); 154 159 ParameterizeOperators(); 160 } 161 protected override void DimensionOnChanged() { 162 base.DimensionOnChanged(); 163 if (Dimension != OrienteeringProblemData.Cities) 164 Dimension = OrienteeringProblemData.Cities; 155 165 } 156 166 … … 159 169 OrienteeringProblemDataParameter = { ActualName = OrienteeringProblemDataParameter.Name } 160 170 }; 161 162 171 Operators.Add(new OrienteeringLocalImprovementOperator() { 163 172 OrienteeringProblemDataParameter = { ActualName = OrienteeringProblemDataParameter.Name } -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.PTSP/3.3/ProbabilisticTSP.cs
r17533 r17544 70 70 71 71 ProbabilisticTSPData = new ProbabilisticTSPData(); 72 Encoding.Length = ProbabilisticTSPData.Cities; 73 } 74 75 protected override void OnEncodingChanged() { 76 base.OnEncodingChanged(); 77 Encoding.Length = ProbabilisticTSPData.Cities; 72 Dimension = ProbabilisticTSPData.Cities; 78 73 } 79 74 … … 112 107 throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates."); 113 108 114 Encoding.Length= data.Dimension;109 Dimension = data.Dimension; 115 110 Name = data.Name; 116 111 Description = data.Description; -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs
r17382 r17544 102 102 LowerBoundParameter = cloner.Clone(original.LowerBoundParameter); 103 103 AverageQualityParameter = cloner.Clone(original.AverageQualityParameter); 104 RegisterEventHandlers();105 104 } 106 105 public QuadraticAssignmentProblem() … … 133 132 134 133 InitializeOperators(); 135 RegisterEventHandlers();136 134 } 137 135 … … 155 153 } 156 154 157 [StorableHook(HookType.AfterDeserialization)]158 private void AfterDeserialization() {159 // BackwardsCompatibility3.3160 #region Backwards compatible code, remove with 3.4161 if (BestKnownSolutionsParameter == null)162 BestKnownSolutionsParameter = (IValueParameter<ItemSet<Permutation>>)Parameters["BestKnownSolutions"];163 if (BestKnownSolutionParameter == null)164 BestKnownSolutionParameter = (IValueParameter<Permutation>)Parameters["BestKnownSolution"];165 if (WeightsParameter == null)166 WeightsParameter = (IValueParameter<DoubleMatrix>)Parameters["Weights"];167 if (DistancesParameter == null)168 DistancesParameter = (IValueParameter<DoubleMatrix>)Parameters["Distances"];169 if (LowerBoundParameter == null)170 LowerBoundParameter = (IValueParameter<DoubleValue>)Parameters["LowerBound"];171 if (AverageQualityParameter == null)172 AverageQualityParameter = (IValueParameter<DoubleValue>)Parameters["AverageQuality"];173 #endregion174 RegisterEventHandlers();175 }176 177 155 #region Events 178 156 protected override void OnEncodingChanged() { 179 157 base.OnEncodingChanged(); 180 Encoding.Length= Weights.Rows;158 Dimension = Weights.Rows; 181 159 Parameterize(); 182 160 } … … 191 169 #endregion 192 170 193 private void RegisterEventHandlers() { 194 Encoding.LengthParameter.Value.ValueChanged += EncodingLengthOnChanged; 195 } 196 197 private void EncodingLengthOnChanged(object sender, EventArgs e) { 198 if (Encoding.Length != Weights.Rows) Encoding.Length = Weights.Rows; 171 protected override void DimensionOnChanged() { 172 base.DimensionOnChanged(); 173 if (Dimension != Weights.Rows) Dimension = Weights.Rows; 199 174 } 200 175 … … 354 329 Weights = weights; 355 330 Distances = distances; 356 Encoding.Length= weights.Rows;331 Dimension = weights.Rows; 357 332 358 333 BestKnownQualityParameter.Value = null; -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions.MultiObjective/3.3/MultiObjectiveTestFunctionProblem.cs
r17320 r17544 37 37 public class MultiObjectiveTestFunctionProblem : RealVectorMultiObjectiveProblem, IProblemInstanceConsumer<MOTFData>, IMultiObjectiveProblemDefinition<RealVectorEncoding, RealVector> { 38 38 #region Parameter Properties 39 public IFixedValueParameter<IntValue> ProblemSizeParameter {40 get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }41 }42 39 public IFixedValueParameter<IntValue> ObjectivesParameter { 43 40 get { return (IFixedValueParameter<IntValue>)Parameters["Objectives"]; } 44 }45 public IValueParameter<DoubleMatrix> BoundsParameter {46 get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }47 41 } 48 42 public IValueParameter<IMultiObjectiveTestFunction> TestFunctionParameter { … … 52 46 53 47 #region Properties 54 public int ProblemSize {55 get { return ProblemSizeParameter.Value.Value; }56 set { ProblemSizeParameter.Value.Value = value; }57 }58 48 public new int Objectives { 59 49 get { return ObjectivesParameter.Value.Value; } 60 50 set { ObjectivesParameter.Value.Value = value; } 61 }62 public DoubleMatrix Bounds {63 get { return BoundsParameter.Value; }64 set { BoundsParameter.Value = value; }65 51 } 66 52 public IMultiObjectiveTestFunction TestFunction { … … 85 71 86 72 public MultiObjectiveTestFunctionProblem() : base() { 87 Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));88 73 Parameters.Add(new FixedValueParameter<IntValue>("Objectives", "The dimensionality of the solution vector (number of objectives).", new IntValue(2))); 89 Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -4, 4 } })));90 74 Parameters.Add(new ValueParameter<IMultiObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Fonseca())); 91 75 92 Encoding.LengthParameter = ProblemSizeParameter;93 Encoding.BoundsParameter = BoundsParameter;94 76 BestKnownFrontParameter.Hidden = true; 95 77 … … 101 83 private void RegisterEventHandlers() { 102 84 TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged; 103 ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;104 85 ObjectivesParameter.Value.ValueChanged += ObjectivesOnValueChanged; 105 86 } … … 156 137 } 157 138 139 protected override void DimensionOnChanged() { 140 base.DimensionOnChanged(); 141 if (Dimension < TestFunction.MinimumSolutionLength || Dimension > TestFunction.MaximumSolutionLength) 142 Dimension = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, Dimension)); 143 UpdateParameterValues(); 144 } 145 158 146 private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) { 159 ProblemSize = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(ProblemSize, TestFunction.MaximumSolutionLength));147 Dimension = Math.Max(TestFunction.MinimumSolutionLength, Math.Min(Dimension, TestFunction.MaximumSolutionLength)); 160 148 Objectives = Math.Max(TestFunction.MinimumObjectives, Math.Min(Objectives, TestFunction.MaximumObjectives)); 161 149 Parameters.Remove(ReferencePointParameterName); … … 163 151 UpdateParameterValues(); 164 152 OnReset(); 165 }166 167 private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {168 ProblemSize = Math.Min(TestFunction.MaximumSolutionLength, Math.Max(TestFunction.MinimumSolutionLength, ProblemSize));169 UpdateParameterValues();170 153 } 171 154 -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
r17382 r17544 42 42 43 43 #region Parameter Properties 44 private IFixedValueParameter<IntValue> ProblemSizeParameter {45 get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }46 }47 private IValueParameter<DoubleMatrix> BoundsParameter {48 get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }49 }50 44 public OptionalValueParameter<RealVector> BestKnownSolutionParameter { 51 45 get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; } … … 57 51 58 52 #region Properties 59 public int ProblemSize {60 get { return ProblemSizeParameter.Value.Value; }61 set { ProblemSizeParameter.Value.Value = value; }62 }63 public DoubleMatrix Bounds {64 get { return BoundsParameter.Value; }65 set { BoundsParameter.Value = value; }66 }67 53 public ISingleObjectiveTestFunction TestFunction { 68 54 get { return TestFunctionParameter.Value; } … … 79 65 public SingleObjectiveTestFunctionProblem() 80 66 : base(new RealVectorEncoding("Point")) { 81 Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));82 Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -100, 100 } })));83 67 Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance.")); 84 68 Parameters.Add(new ValueParameter<ISingleObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Ackley())); 85 69 Maximization = TestFunction.Maximization; 86 70 87 Encoding.LengthParameter = ProblemSizeParameter;88 Encoding.BoundsParameter = BoundsParameter;89 71 BestKnownQuality = TestFunction.BestKnownQuality; 90 72 … … 105 87 Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged; 106 88 TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged; 107 ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;108 BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;109 89 } 110 90 … … 156 136 Parameterize(); 157 137 } 138 protected override void DimensionOnChanged() { 139 base.DimensionOnChanged(); 140 if (Dimension < TestFunction.MinimumProblemSize || Dimension > TestFunction.MaximumProblemSize) 141 Dimension = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, Dimension)); 142 } 143 protected override void BoundsOnChanged() { 144 base.BoundsOnChanged(); 145 Parameterize(); 146 } 158 147 private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) { 159 148 Parameterize(); 160 149 } 161 150 private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) { 162 var problemSizeChange = ProblemSize< TestFunction.MinimumProblemSize163 || ProblemSize> TestFunction.MaximumProblemSize;151 var problemSizeChange = Dimension < TestFunction.MinimumProblemSize 152 || Dimension > TestFunction.MaximumProblemSize; 164 153 if (problemSizeChange) { 165 ProblemSize = Math.Max(TestFunction.MinimumProblemSize, Math.Min(ProblemSize, TestFunction.MaximumProblemSize));154 Dimension = Math.Max(TestFunction.MinimumProblemSize, Math.Min(Dimension, TestFunction.MaximumProblemSize)); 166 155 } 167 156 BestKnownQuality = TestFunction.BestKnownQuality; 168 157 Bounds = (DoubleMatrix)TestFunction.Bounds.Clone(); 169 var bestSolution = TestFunction.GetBestKnownSolution( ProblemSize);158 var bestSolution = TestFunction.GetBestKnownSolution(Dimension); 170 159 BestKnownSolutionParameter.Value = bestSolution; 171 160 Maximization = TestFunction.Maximization; 172 161 173 162 OnReset(); 174 }175 private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {176 if (ProblemSize < TestFunction.MinimumProblemSize177 || ProblemSize > TestFunction.MaximumProblemSize)178 ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));179 }180 private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {181 Parameterize();182 163 } 183 164 #endregion -
branches/2521_ProblemRefactoring/HeuristicLab.Problems.TravelingSalesman/3.3/TSP.cs
r17525 r17544 76 76 77 77 TSPData = new EuclideanTSPData(); 78 Encoding.Length= TSPData.Cities;78 Dimension = TSPData.Cities; 79 79 80 80 InitializeOperators(); … … 140 140 throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates."); 141 141 142 Encoding.Length= data.Dimension;142 Dimension = data.Dimension; 143 143 Name = data.Name; 144 144 Description = data.Description; … … 212 212 protected override void OnEncodingChanged() { 213 213 base.OnEncodingChanged(); 214 Encoding.Length= TSPData.Cities;214 Dimension = TSPData.Cities; 215 215 ParameterizeOperators(); 216 216 } -
branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/EsGriewankSampleTest.cs
r17226 r17544 64 64 SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem(); 65 65 66 problem. ProblemSize= 10;66 problem.Dimension = 10; 67 67 problem.TestFunction = new Griewank(); 68 68 problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator(); -
branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/OSESGriewankSampleTest.cs
r17226 r17544 63 63 SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem(); 64 64 65 problem. ProblemSize= 10;65 problem.Dimension = 10; 66 66 problem.TestFunction = new Griewank(); 67 67 problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator(); -
branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SimulatedAnnealingRastriginSampleTest.cs
r17356 r17544 62 62 problem.Bounds = new DoubleMatrix(new double[,] { { -5.12, 5.12 } }); 63 63 problem.TestFunction= new Rastrigin(); 64 problem. ProblemSize= 2;64 problem.Dimension = 2; 65 65 problem.Encoding.SolutionCreator = new UniformRandomRealVectorCreator(); 66 66 #endregion -
branches/2521_ProblemRefactoring/HeuristicLab.Tests/HeuristicLab.Algorithms.ParameterlessPopulationPyramid-3.3/ParameterlessPopulationPyramidTest.cs
r17226 r17544 60 60 public void P3DeceptiveTrap() { 61 61 var problem = new DeceptiveTrapProblem(); 62 problem. Length = 49;62 problem.NumberOfTraps = 7; 63 63 problem.TrapSize = 7; 64 64 DoRun(problem, 100, 123, 0.857142857142857, 50); 65 65 DoRun(problem, 9876, 123, 0.918367346938776, 981); 66 66 DoRun(problem, 20000, 987, 1, 19977); 67 problem. Length = 700;67 problem.NumberOfTraps = 100; 68 68 DoRun(problem, 100000, 987, 0.941428571428571, 96901); 69 69 } … … 75 75 public void P3DeceptiveStepTrap() { 76 76 var problem = new DeceptiveStepTrapProblem(); 77 problem. Length = 49;77 problem.NumberOfTraps = 7; 78 78 problem.TrapSize = 7; 79 79 problem.StepSize = 2; … … 81 81 DoRun(problem, 9876, 123, 0.785714285714286, 3489); 82 82 DoRun(problem, 70000, 987, 1, 68292); 83 problem. Length = 700;83 problem.NumberOfTraps = 100; 84 84 DoRun(problem, 100000, 987, 0.76, 58711); 85 85 } … … 91 91 public void P3HIFF() { 92 92 var problem = new HIFFProblem(); 93 problem. Length= 32;93 problem.Dimension = 32; 94 94 DoRun(problem, 50, 12345, 0.375, 26); 95 95 DoRun(problem, 1000, 12345, 1, 976); 96 problem. Length= 512;96 problem.Dimension = 512; 97 97 DoRun(problem, 1000, 54321, 0.17361111111111, 440); 98 98 DoRun(problem, 130000, 54321, 1, 89214);
Note: See TracChangeset
for help on using the changeset viewer.