Changeset 2202 for branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionBase.cs

Timestamp:

07/28/09 19:24:23 (15 years ago)

Author:

gkronber

Message:

Created a branch for #713

Location:

branches/GP-Refactoring-713

Files:

• . (copied) (copied from trunk)
• sources/HeuristicLab.GP/3.3/FunctionBase.cs (modified) (2 diffs)

branches/GP-Refactoring-713/sources/HeuristicLab.GP/3.3/FunctionBase.cs

@@ -30 +30 @@
 
 namespace HeuristicLab.GP {
-  /// <summary>
-  /// Functions are like operators except that they do not allow sub-operators and the normal form of evaluation
-  /// is to evaluate all children first.
-  /// </summary>
-  public abstract class FunctionBase : OperatorBase, IFunction {
-    public const string INITIALIZATION = "Initialization";
-    public const string MANIPULATION = "Manipulation";
-    private List<IFunction>[] allowedSubFunctions;
+  public abstract class FunctionBase : ItemBase, IFunction {
+    private List<List<IFunction>> allowedSubFunctions = new List<List<IFunction>>();
     private int minArity = -1;
     private int maxArity = -1;
-
-    public virtual double Apply() {
-      throw new NotImplementedException();
+    private double tickets = 1.0;
+    private IOperator initializer;
+    private IOperator manipulator;
+    private int minTreeHeight = -1;
+    private int minTreeSize = -1;
+
+    public virtual string Name {
+      get { return this.GetType().Name; }
+    }
+
+    public virtual string Description {
+      get { return "Description for this function is missing (TODO)"; }
+    }
+
+    public int MinArity {
+      get {
+        return minArity;
+      }
+      protected set {
+        minArity = value;
+        while (minArity > allowedSubFunctions.Count) allowedSubFunctions.Add(new List<IFunction>());
+      }
+    }
+
+    public int MaxArity {
+      get {
+        return maxArity;
+      }
+      protected set {
+        maxArity = value;
+        while (allowedSubFunctions.Count > maxArity) allowedSubFunctions.RemoveAt(allowedSubFunctions.Count - 1);
+        while (maxArity > allowedSubFunctions.Count) allowedSubFunctions.Add(new List<IFunction>());
+      }
+    }
+
+
+    public int MinTreeSize {
+      get {
+        if (minTreeSize <= 0) RecalculateMinimalTreeSize();
+        return minTreeSize;
+      }
+    }
+
+    public int MinTreeHeight {
+      get {
+        if (minTreeHeight <= 0) RecalculateMinimalTreeHeight();
+        return minTreeHeight;
+      }
+    }
+
+    public double Tickets {
+      get { return tickets; }
+      set {
+        if (value < 0.0) throw new ArgumentException("Number of tickets must be positive");
+        else tickets = value;
+      }
+    }
+
+    public IOperator Initializer {
+      get { return initializer; }
+      set { initializer = value; }
+    }
+
+    public IOperator Manipulator {
+      get { return manipulator; }
+      set { manipulator = value; }
+    }
+
+    public virtual IEnumerable<string> LocalParameterNames {
+      get { return new string[0]; }
     }
 
@@ -49 +110 @@
     }
 
-    public int MinArity {
-      get {
-        if(minArity < 0) RefreshArity();
-        return minArity;
-      }
-    }
-
-    public int MaxArity {
-      get {
-        if(maxArity < 0) RefreshArity();
-        return maxArity;
-      }
-    }
-
-    private void RefreshArity() {
-      minArity = 2; maxArity = 2; // default arity is 2
-      foreach(IConstraint constraint in Constraints) {
-        NumberOfSubOperatorsConstraint theConstraint = constraint as NumberOfSubOperatorsConstraint;
-        if(theConstraint != null) {
-          minArity = theConstraint.MinOperators.Data;
-          maxArity = theConstraint.MaxOperators.Data;
+
+    //private List<IConstraint> constraints = new List<IConstraint>();
+    //public ICollection<IConstraint> Constraints {
+    //  get { return constraints; }
+    //}
+
+    //private void RefreshArity() {
+    //  minArity = 2; maxArity = 2; // default arity is 2
+    //  foreach (IConstraint constraint in Constraints) {
+    //    NumberOfSubOperatorsConstraint theConstraint = constraint as NumberOfSubOperatorsConstraint;
+    //    if (theConstraint != null) {
+    //      minArity = theConstraint.MinOperators.Data;
+    //      maxArity = theConstraint.MaxOperators.Data;
+    //    }
+    //  }
+    //}
+
+    public ICollection<IFunction> GetAllowedSubFunctions(int index) {
+      if (index < 0 || index > MaxArity) throw new ArgumentException("Index outside of allowed range. index = " + index);
+      //if (allowedSubFunctions == null) {
+      //  // first time: analyze the constraint and create a cached copy of the allowed sub-functions
+      //  allowedSubFunctions = new List<IFunction>[MaxArity];
+      //  for (int i = 0; i < MaxArity; i++) {
+      //    allowedSubFunctions[i] = GetAllowedSubFunctions(i);
+      //  }
+      //}
+      return allowedSubFunctions[index];
+    }
+
+    public void AddAllowedSubFunction(IFunction function, int index) {
+      if (index < 0 || index > MaxArity) throw new ArgumentException("Index outside of allowed range. index = " + index);
+      if (allowedSubFunctions[index] == null) {
+        allowedSubFunctions[index] = new List<IFunction>();
+      }
+      if (!allowedSubFunctions[index].Contains(function)) {
+        allowedSubFunctions[index].Add(function);
+      }
+    }
+
+    public void RemoveAllowedSubFunction(IFunction function, int index) {
+      if (index < 0 || index > MaxArity) throw new ArgumentException("Index outside of allowed range. index = " + index);
+      allowedSubFunctions[index].Add(function);
+    }
+
+    public bool IsAllowedSubFunction(IFunction function, int index) {
+      return GetAllowedSubFunctions(index).Contains(function);
+    }
+
+    //private List<IFunction> GetAllowedSubFunctions(int index) {
+    //  List<IFunction> allowedSubFunctions = new List<IFunction>();
+    //  foreach (IConstraint constraint in Constraints) {
+    //    if (constraint is SubOperatorTypeConstraint) {
+    //      SubOperatorTypeConstraint subOpConstraint = constraint as SubOperatorTypeConstraint;
+    //      if (subOpConstraint.SubOperatorIndex.Data == index) {
+    //        foreach (IFunction f in subOpConstraint.AllowedSubOperators) allowedSubFunctions.Add(f);
+    //        subOpConstraint.Changed += new EventHandler(subOpConstraint_Changed); // register an event-handler to invalidate the cache on constraint changes
+    //        return allowedSubFunctions;
+    //      }
+    //    } else if (constraint is AllSubOperatorsTypeConstraint) {
+    //      AllSubOperatorsTypeConstraint subOpConstraint = constraint as AllSubOperatorsTypeConstraint;
+    //      foreach (IFunction f in subOpConstraint.AllowedSubOperators) allowedSubFunctions.Add(f);
+    //      subOpConstraint.Changed += new EventHandler(subOpConstraint_Changed); // register an event-handler to invalidate the cache on constraint changes
+    //      return allowedSubFunctions;
+    //    }
+    //  }
+    //  return allowedSubFunctions;
+    //}
+
+    //private void subOpConstraint_Changed(object sender, EventArgs e) {
+    //  allowedSubFunctions = null;
+    //}
+
+    public override IView CreateView() {
+      return new FunView(this);
+    }
+
+    private void RecalculateMinimalTreeSize() {
+      minTreeSize = int.MaxValue;
+      int sum = 1;
+      int minSize = int.MaxValue;
+      for (int i = 0; i < MinArity; i++) {
+        foreach (IFunction subFun in GetAllowedSubFunctions(i)) {
+          minSize = Math.Min(minSize, subFun.MinTreeSize);
         }
-      }
-    }
-
-    public IList<IFunction> AllowedSubFunctions(int index) {
-      if(allowedSubFunctions == null) {
-        // first time: analyze the constraint and create a cached copy of the allowed sub-functions
-        allowedSubFunctions = new List<IFunction>[MaxArity];
-        for(int i = 0; i < MaxArity; i++) {
-          allowedSubFunctions[i] = GetAllowedSubFunctions(i);
+        sum += minSize;
+      }
+      minTreeSize = sum;
+    }
+
+    private void RecalculateMinimalTreeHeight() {
+      minTreeHeight = int.MaxValue;
+      int height = 0;
+      int minHeight = int.MaxValue;
+      for (int i = 0; i < MinArity; i++) {
+        foreach (IFunction subFun in GetAllowedSubFunctions(i)) {
+          minHeight = Math.Min(minHeight, subFun.MinTreeHeight);
         }
-      }
-      return allowedSubFunctions[index];
-    }
-
-    private List<IFunction> GetAllowedSubFunctions(int index) {
-      List<IFunction> allowedSubFunctions = new List<IFunction>();
-      foreach(IConstraint constraint in Constraints) {
-        if(constraint is SubOperatorTypeConstraint) {
-          SubOperatorTypeConstraint subOpConstraint = constraint as SubOperatorTypeConstraint;
-          if(subOpConstraint.SubOperatorIndex.Data == index) {
-            foreach(IFunction f in subOpConstraint.AllowedSubOperators) allowedSubFunctions.Add(f);
-            subOpConstraint.Changed += new EventHandler(subOpConstraint_Changed); // register an event-handler to invalidate the cache on constraing changes
-            return allowedSubFunctions;
-          }
-        } else if(constraint is AllSubOperatorsTypeConstraint) {
-          AllSubOperatorsTypeConstraint subOpConstraint = constraint as AllSubOperatorsTypeConstraint;
-          foreach(IFunction f in subOpConstraint.AllowedSubOperators) allowedSubFunctions.Add(f);
-          subOpConstraint.Changed += new EventHandler(subOpConstraint_Changed); // register an event-handler to invalidate the cache on constraint changes
-          return allowedSubFunctions;
-        }
-      }
-      return allowedSubFunctions;
-    }
-
-    private void subOpConstraint_Changed(object sender, EventArgs e) {
-      allowedSubFunctions = null;
-    }
-
-    // operator-tree style evaluation is not supported for functions.
-    public override IOperation Apply(IScope scope) {
-      throw new NotSupportedException();
-    }
-
-    private static readonly List<IOperator> emptySubOperatorList = new List<IOperator>();
-    public override IList<IOperator> SubOperators {
-      get { return emptySubOperatorList; }
-    }
-
-    public override void AddSubOperator(IOperator subOperator) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryAddSubOperator(IOperator subOperator) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryAddSubOperator(IOperator subOperator, int index) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryAddSubOperator(IOperator subOperator, int index, out ICollection<IConstraint> violatedConstraints) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryAddSubOperator(IOperator subOperator, out ICollection<IConstraint> violatedConstraints) {
-      throw new NotSupportedException();
-    }
-
-    public override void AddSubOperator(IOperator subOperator, int index) {
-      throw new NotSupportedException();
-    }
-
-    public override void RemoveSubOperator(int index) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryRemoveSubOperator(int index) {
-      throw new NotSupportedException();
-    }
-
-    public override bool TryRemoveSubOperator(int index, out ICollection<IConstraint> violatedConstraints) {
-      throw new NotSupportedException();
+        height = Math.Max(height, minHeight);
+      }
+      minTreeHeight = height + 1;
     }
   }