Changeset 12405 for branches/TerminationCriteria/HeuristicLab.Termination

Timestamp:

05/27/15 14:30:56 (10 years ago)

Author:

pfleck

Message:

#2027

• Uses FixedValueParameters and added some properties.
• Added the comparison-symbol in the string-representation of Terminators.
• Renamed Terminator parameter to Termination to use a more neutral term.
• Used Red-Flag as Termination-Icon.

Location:

branches/TerminationCriteria/HeuristicLab.Termination/3.3

Files:

• ComparisonTerminator.cs (modified) (1 diff)
• ExecutionTimeTerminator.cs (modified) (2 diffs)
• MultiTerminator.cs (modified) (1 diff)
• TerminationOperator.cs (modified) (3 diffs)
• Terminator.cs (modified) (2 diffs)
• ThresholdTerminator.cs (modified) (2 diffs)
• Views/ThresholdTerminatorView.Designer.cs (modified) (1 diff)
• Views/ThresholdTerminatorView.cs (modified) (1 diff)

branches/TerminationCriteria/HeuristicLab.Termination/3.3/ComparisonTerminator.cs

@@ -30 +30 @@
   [Item("ComparisonTerminator", "An termination criterion which compares two values.")]
   [StorableClass]
-  public class ComparisonTerminator<T> : ThresholdTerminator<T> where T : class, IItem, IComparable {
-    public ILookupParameter<T> ValueParameter {
-      get { return (ILookupParameter<T>)Parameters["Value"]; }
+  public class ComparisonTerminator<T> : ThresholdTerminator<T> where T : class, IItem, IComparable, new() {
+    public ILookupParameter<T> ComparisonValueParameter {
+      get { return (ILookupParameter<T>)Parameters["ComparisonValue"]; }
     }
 
-    private ValueParameter<Comparison> ComparisonParameter {
-      get { return (ValueParameter<Comparison>)Parameters["Comparison"]; }
+    private IFixedValueParameter<Comparison> ComparisonParameter {
+      get { return (IFixedValueParameter<Comparison>)Parameters["Comparison"]; }
     }
 
-    public Comparison Comparison {
-      get { return ComparisonParameter.Value; }
-      set { ComparisonParameter.Value = value; }
+    public ComparisonType Comparison {
+      get { return ComparisonParameter.Value.Value; }
+      set { ComparisonParameter.Value.Value = value; }
     }
 
     [StorableConstructor]
     protected ComparisonTerminator(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
     protected ComparisonTerminator(ComparisonTerminator<T> original, Cloner cloner)
-      : base(original, cloner) { }
+      : base(original, cloner) {
+      Initialize();
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ComparisonTerminator<T>(this, cloner);
     }
-    public ComparisonTerminator()
-      : base() {
-      Parameters.Add(new LookupParameter<T>("Value", "The left side value of the comparison."));
-      Parameters.Add(new ValueParameter<Comparison>("Comparison", "The type of comparison.", new Comparison(ComparisonType.GreaterOrEqual)) { Hidden = true });
+    public ComparisonTerminator(T threshold = default(T))
+      : base(threshold) {
+      Parameters.Add(new LookupParameter<T>("ComparisonValue", "The left side value of the comparison.") { Hidden = false });
+      Parameters.Add(new FixedValueParameter<Comparison>("Comparison", "The type of comparison."));
+      Initialize();
     }
-    public ComparisonTerminator(string leftSideActualName, string rightSideActualName, ComparisonType comparison = ComparisonType.GreaterOrEqual)
-      : this() {
-      ValueParameter.ActualName = leftSideActualName;
-      ThresholdParameter.ActualName = rightSideActualName;
-      Comparison.Value = comparison;
+    public ComparisonTerminator(string comparisonValueActualName, ComparisonType comparison = default(ComparisonType), T threshold = default(T))
+      : this(threshold) {
+      ComparisonValueParameter.ActualName = comparisonValueActualName;
+      Comparison = comparison;
     }
-    public ComparisonTerminator(string leftSideActualName, T rightSideValue, ComparisonType comparison = ComparisonType.GreaterOrEqual)
-      : this() {
-      ValueParameter.ActualName = leftSideActualName;
-      ThresholdParameter.Value = rightSideValue;
-      Comparison.Value = comparison;
+
+    private void Initialize() {
+      ComparisonParameter.ToStringChanged += (s, a) => OnToStringChanged();
     }
 
     protected override bool CheckTermination() {
-      IComparable lhs = ValueParameter.ActualValue;
-      IComparable rhs = ThresholdParameter.ActualValue;
+      IComparable lhs = ComparisonValueParameter.ActualValue;
+      IComparable rhs = ThresholdParameter.Value;
 
+      return Comparison.Compare(lhs, rhs);
+    }
+
+    public override string ToString() {
+      if (Threshold == null) return Name;
+      else return string.Format("{0} {1} {2}", Name, Comparison.ToSymbol(), ThresholdParameter.Value);
+    }
+  }
+
+  internal static class ComparisonTypeHelper {
+    public static bool Compare(this ComparisonType comparison, IComparable lhs, IComparable rhs) {
       int i = lhs.CompareTo(rhs);
-      switch (Comparison.Value) {
-        case ComparisonType.Less:
-          return i < 0;
-        case ComparisonType.LessOrEqual:
-          return i <= 0;
-        case ComparisonType.Equal:
-          return i == 0;
-        case ComparisonType.GreaterOrEqual:
-          return i >= 0;
-        case ComparisonType.Greater:
-          return i > 0;
-        case ComparisonType.NotEqual:
-          return i != 0;
-        default:
-          throw new InvalidOperationException(Name + ": " + Comparison.Value + " is not supported.");
+      switch (comparison) {
+        case ComparisonType.Less: return i < 0;
+        case ComparisonType.LessOrEqual: return i <= 0;
+        case ComparisonType.Equal: return i == 0;
+        case ComparisonType.GreaterOrEqual: return i >= 0;
+        case ComparisonType.Greater: return i > 0;
+        case ComparisonType.NotEqual: return i != 0;
+        default: throw new InvalidOperationException(comparison + " is not supported.");
+      }
+    }
+
+    public static string ToSymbol(this ComparisonType comparison) {
+      switch (comparison) {
+        case ComparisonType.Less: return "<";
+        case ComparisonType.LessOrEqual: return "<=";
+        case ComparisonType.Equal: return "=";
+        case ComparisonType.GreaterOrEqual: return ">=";
+        case ComparisonType.Greater: return ">";
+        case ComparisonType.NotEqual: return "!=";
+        default: throw new InvalidOperationException(comparison + " is not supported.");
       }
     }

branches/TerminationCriteria/HeuristicLab.Termination/3.3/ExecutionTimeTerminator.cs

@@ -44 +44 @@
     }
     public ExecutionTimeTerminator(IExecutable executable)
-      : this(executable, new TimeSpan(0, 10, 0)) { }
-    public ExecutionTimeTerminator(IExecutable executable, TimeSpan maximumExecutionTime) {
+      : this(executable, new TimeSpanValue(new TimeSpan(0, 10, 0))) { }
+    public ExecutionTimeTerminator(IExecutable executable, TimeSpanValue maximumExecutionTime)
+      : base(maximumExecutionTime) {
       this.executable = executable;
-      ThresholdParameter.Value = new TimeSpanValue(maximumExecutionTime);
-
       Name = "Execution Time";
     }
@@ -57 +56 @@
       return executable.ExecutionTime > max;
     }
+
+    public override string ToString() {
+      if (Threshold == null) return Name;
+      else return string.Format("{0} {1} {2}", Name, ">", ThresholdParameter.Value);
+    }
   }
 }

branches/TerminationCriteria/HeuristicLab.Termination/3.3/MultiTerminator.cs

@@ -35 +35 @@
   public sealed class MultiTerminator : CheckedMultiOperator<ITerminator>, ITerminator {
     public static new Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Object; }
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.FlagRed; }
     }
     public override Image ItemImage {

branches/TerminationCriteria/HeuristicLab.Termination/3.3/TerminationOperator.cs

@@ -31 +31 @@
   [StorableClass]
   public sealed class TerminationOperator : InstrumentedOperator {
-    public ILookupParameter<ITerminator> TerminatorParameter {
-      get { return (ILookupParameter<ITerminator>)Parameters["Terminator"]; }
+    public ILookupParameter<ITerminator> TerminationParameter {
+      get { return (ILookupParameter<ITerminator>)Parameters["Termination"]; }
     }
     public ILookupParameter<BoolValue> TerminateParameter {
@@ -64 +64 @@
     public TerminationOperator()
       : base() {
-      Parameters.Add(new LookupParameter<ITerminator>("Terminator", "The termination criteria which sould be checked."));
+      Parameters.Add(new LookupParameter<ITerminator>("Termination", "The termination criteria which sould be checked."));
       Parameters.Add(new LookupParameter<BoolValue>("Terminate", "The parameter which will be set to determine if execution should be terminated or schould continue."));
       Parameters.Add(new OperatorParameter("ContinueBranch", "The operator which is executed if no termination criteria has met."));
@@ -74 +74 @@
 
       var placeholder = new Placeholder() { Name = "Check termination criteria (Placeholder)" };
-      placeholder.OperatorParameter.ActualName = TerminatorParameter.Name;
+      placeholder.OperatorParameter.ActualName = TerminationParameter.Name;
 
       BeforeExecutionOperators.Add(assigner);

branches/TerminationCriteria/HeuristicLab.Termination/3.3/Terminator.cs

@@ -20 +20 @@
 #endregion
 
+using System.Drawing;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31 +32 @@
   [StorableClass]
   public abstract class Terminator : InstrumentedOperator, ITerminator {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.FlagRed; }
+    }
+
     public ILookupParameter<BoolValue> TerminateParameter {
       get { return (ILookupParameter<BoolValue>)Parameters["Terminate"]; }

branches/TerminationCriteria/HeuristicLab.Termination/3.3/ThresholdTerminator.cs

@@ -29 +29 @@
   [Item("ThresholdTerminator", "Base class for all termination criteria which specifies some threshold.")]
   [StorableClass]
-  public abstract class ThresholdTerminator<T> : Terminator where T : class, IItem {
-    public IValueLookupParameter<T> ThresholdParameter {
-      get { return (IValueLookupParameter<T>)Parameters["Threshold"]; }
+  public abstract class ThresholdTerminator<T> : Terminator where T : class, IItem, new() {
+    public IFixedValueParameter<T> ThresholdParameter {
+      get { return (IFixedValueParameter<T>)Parameters["Threshold"]; }
+    }
+
+    public T Threshold {
+      get { return ThresholdParameter.Value; }
     }
 
@@ -44 +48 @@
       Initialize();
     }
-    protected ThresholdTerminator()
+    protected ThresholdTerminator(T threshold = default(T))
       : base() {
-      Parameters.Add(new ValueLookupParameter<T>("Threshold", "The limit of the termiation criterion."));
-
+      Parameters.Add(new FixedValueParameter<T>("Threshold", "The limit of the termiation criterion.", threshold));
       Initialize();
     }

branches/TerminationCriteria/HeuristicLab.Termination/3.3/Views/ThresholdTerminatorView.Designer.cs

@@ -20 +20 @@
 #endregion
 
+using System;
+using HeuristicLab.Core;
+
 namespace HeuristicLab.Termination.Views {
-  partial class ThresholdTerminatorView<T> {
+  partial class ThresholdTerminatorView<T> where T : class, IItem, IComparable, new() {
     /// <summary> 
     /// Required designer variable.

branches/TerminationCriteria/HeuristicLab.Termination/3.3/Views/ThresholdTerminatorView.cs

@@ -29 +29 @@
   [View("ThresholdTerminator View")]
   [Content(typeof(ThresholdTerminator<>), true)]
-  public partial class ThresholdTerminatorView<T> : ItemView where T : class, IItem, IComparable {
+  public partial class ThresholdTerminatorView<T> : ItemView where T : class, IItem, IComparable, new() {
 
     public new ThresholdTerminator<T> Content {