Changeset 11739 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs

Timestamp:

01/08/15 15:52:05 (9 years ago)

Author:

mkommend

Message:

#2174: Worked on operators and programmable problem base classes and scripts.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New

Files:

• . (added)
• SingleObjectiveProgrammableProblem.cs (moved) (moved from branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs) (1 diff)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/SingleObjectiveProgrammableProblem.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.Programmable {
-  [Item("Programmable Problem (single-objective)", "Represents a single-objective problem that can be programmed.")]
-  [Creatable("Problems")]
   [StorableClass]
-  public class SingleObjectiveProgrammableProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveProgrammableProblemEvaluator, ISolutionCreator>, IParameterizedNamedItem, IStorableContent {
-    public string Filename { get; set; }
-
-    public static new Image StaticItemImage {
-      get { return Common.Resources.VSImageLibrary.Script; }
-    }
-
-    public new ParameterCollection Parameters {
-      get { return base.Parameters; }
-    }
-    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
-      get { return Parameters; }
-    }
-
-    public IValueParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
-      get { return (IValueParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
-    }
-
-    protected IValueParameter<IEncoding> EncodingParameter {
-      get { return (IValueParameter<IEncoding>)Parameters["Encoding"]; }
-    }
-
-    public ISingleObjectiveProblemDefinition ProblemDefinition {
-      get { return ProblemDefinitionParameter.Value; }
-      set { ProblemDefinitionParameter.Value = value; }
-    }
-
-
-    public override IEnumerable<IParameterizedItem> ExecutionContextItems {
-      get { return base.ExecutionContextItems.Concat(new[] { ProblemDefinition.Encoding }); }
-    }
-    protected override IEnumerable<IItem> GetOperators() {
-      return base.GetOperators().Concat(ProblemDefinition.Encoding.Operators);
-    }
-
+  public abstract class SingleObjectiveProgrammableProblem<TEncoding> : ProgrammableProblem<TEncoding, SingleObjectiveEvaluator>, ISingleObjectiveProblemDefinition
+  where TEncoding : class, IEncoding {
     [StorableConstructor]
     protected SingleObjectiveProgrammableProblem(bool deserializing) : base(deserializing) { }
 
-    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
+    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem<TEncoding> original, Cloner cloner)
       : base(original, cloner) {
-      RegisterEventHandlers();
+      ParameterizeOperators();
     }
-    public SingleObjectiveProgrammableProblem()
-      : base(new SingleObjectiveEvaluator(), new MultiEncodingCreator()) {
-      Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemScript() { Name = Name }));
-      Parameters.Add(new ValueParameter<IEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
 
+    protected SingleObjectiveProgrammableProblem()
+      : base() {
 
       Operators.Add(new BestScopeSolutionAnalyzer());
+      Operators.Add(new SingleObjectiveEvaluator());
       Operators.Add(new SingleObjectiveAnalyzer());
-      Operators.Add(Evaluator);
 
-      RegisterEventHandlers();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveProgrammableProblem(this, cloner);
+      ParameterizeOperators();
     }
 
     [StorableHook(HookType.AfterDeserialization)]
-    // ReSharper disable UnusedMember.Local
     private void AfterDeserialization() {
-      RegisterEventHandlers();
-    }
-    // ReSharper restore UnusedMember.Local
-
-    private void RegisterEventHandlers() {
-      ProblemDefinitionParameter.ValueChanged += ProblemDefinitionParameterOnValueChanged;
-      RegisterProblemDefinitionEventHandlers();
+      ParameterizeOperators();
     }
 
-    private void ProblemDefinitionParameterOnValueChanged(object sender, EventArgs eventArgs) {
-      RegisterProblemDefinitionEventHandlers();
-      Parameterize();
-    }
+    public abstract bool Maximization { get; }
+    public abstract double Evaluate(Individual individual, IRandom random);
+    public virtual void Analyze(Individual[] individuals, double[] qualities, ResultCollection results) { }
 
-    private void RegisterProblemDefinitionEventHandlers() {
-      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
-      ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionNameChanged;
-    }
-
-    private void ProblemDefinitionNameChanged(object sender, EventArgs eventArgs) {
-      if (sender != ProblemDefinitionParameter.Value) return;
-      Name = ProblemDefinitionParameter.Value.Name;
-    }
-
-    protected override void OnNameChanged() {
-      base.OnNameChanged();
-      ProblemDefinitionParameter.Value.Name = Name;
-    }
 
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
-      Parameterize();
+      ParameterizeOperators();
     }
 
-    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
-      Parameterize();
+    protected override void ParameterizeOperators() {
+      base.ParameterizeOperators();
+      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator>())
+        op.EvaluateFunc = Evaluate;
+      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator>())
+        op.AnalyzeAction = Analyze;
     }
 
-    protected virtual void Parameterize() {
-      var definition = ProblemDefinitionParameter.Value;
-      if (definition == null) return;
-
-      IEncoding encoding = definition.Encoding;
-      SolutionCreator = encoding.SolutionCreator;
-
-      EncodingParameter.Value = encoding;
-      Maximization.Value = definition.IsMaximizationProblem;
-
-      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
-      Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      foreach (var evalOp in Operators.OfType<ISingleObjectiveProgrammableProblemEvaluator>()) {
-        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
-        evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      }
-      foreach (var analyzeOp in Operators.OfType<ISingleObjectiveProgrammableProblemAnalyzer>()) {
-        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
-        analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-        analyzeOp.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-      }
-
-      ConfigureSingleEncodingOperators();
-      UpdateImprovementOperators();
-      UpdateMoveOperators();
-    }
-
-
-    protected virtual void ConfigureSingleEncodingOperators() {
-      foreach (var su in GetOperators().OfType<IRealVectorSwarmUpdater>()) {
-        su.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      }
-    }
-
-    protected virtual void UpdateImprovementOperators() {
-      if (!Operators.Any(x => x is SingleObjectiveImprover))
-        Operators.Add(new SingleObjectiveImprover());
-      foreach (var improver in Operators.OfType<SingleObjectiveImprover>()) {
-        improver.EncodingParameter.ActualName = EncodingParameter.Name;
-        improver.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        improver.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-        improver.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-      }
-    }
-    protected virtual void UpdateMoveOperators() {
-      if (!Operators.Any(x => x is SingleObjectiveMoveGenerator))
-        Operators.Add(new SingleObjectiveMoveGenerator());
-      if (!Operators.Any(x => x is SingleObjectiveMoveEvaluator))
-        Operators.Add(new SingleObjectiveMoveEvaluator());
-      if (!Operators.Any(x => x is SingleObjectiveMoveMaker))
-        Operators.Add(new SingleObjectiveMoveMaker());
-
-      foreach (var generator in Operators.OfType<SingleObjectiveMoveGenerator>()) {
-        generator.EncodingParameter.ActualName = EncodingParameter.Name;
-        generator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      }
-      foreach (var evaluator in Operators.OfType<SingleObjectiveMoveEvaluator>()) {
-        evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
-        evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      }
-      foreach (var maker in Operators.OfType<SingleObjectiveMoveMaker>()) {
-        maker.EncodingParameter.ActualName = EncodingParameter.Name;
-        maker.MoveQualityParameter.ActualName = Operators.OfType<SingleObjectiveMoveEvaluator>().First().MoveQualityParameter.ActualName;
-        maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-      }
-    }
   }
 }