Changeset 2365

Timestamp:

09/16/09 17:14:34 (15 years ago)

Author:

gkronber

Message:

Fixed #747 (GP engines create model with non-zero time-offsets).

Location:

trunk/sources

Files:

• HeuristicLab.GP.StructureIdentification/3.3/Symbols/Variable.cs (modified) (2 diffs)
• HeuristicLab.GP/3.3/BaseClasses/FunctionTreeBase.cs (modified) (1 diff)
• HeuristicLab.Random/3.2/NormalRandomAdder.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Symbols/Variable.cs

@@ -23 +23 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Random;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class Variable : Terminal {    
+  public class Variable : Terminal {
     public const string WEIGHT = "Weight";
     public const string OFFSET = "SampleOffset";
@@ -99 +100 @@
       offsetRandomAdder.GetVariableInfo("Value").ActualName = OFFSET;
       offsetRandomAdder.Name = "Offset Adder";
+      offsetRandomAdder.GetVariableInfo("MinValue").Local = true;
+      offsetRandomAdder.AddVariable(new HeuristicLab.Core.Variable("MinValue", new DoubleData(minOffset)));
+      offsetRandomAdder.GetVariableInfo("MaxValue").Local = true;
+      offsetRandomAdder.AddVariable(new HeuristicLab.Core.Variable("MaxValue", new DoubleData(maxOffset + 1)));
 
       combinedOp.OperatorGraph.AddOperator(seq);

trunk/sources/HeuristicLab.GP/3.3/BaseClasses/FunctionTreeBase.cs

@@ -94 +94 @@
     }
 
-    public virtual string ToString() {
+    public override string ToString() {
       return Function.Name;
     }

trunk/sources/HeuristicLab.Random/3.2/NormalRandomAdder.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Constraints;
 
 namespace HeuristicLab.Random {
@@ -69 +68 @@
     /// </summary>
     public NormalRandomAdder() {
-      AddVariableInfo(new VariableInfo("Mu", "Parameter mu of the normal distribution", typeof(DoubleData), VariableKind.None));
+      AddVariableInfo(new VariableInfo("Mu", "Parameter mu of the normal distribution", typeof(DoubleData), VariableKind.In));
       GetVariableInfo("Mu").Local = true;
       AddVariable(new Variable("Mu", new DoubleData(0.0)));
 
-      AddVariableInfo(new VariableInfo("Sigma", "Parameter sigma of the normal distribution", typeof(DoubleData), VariableKind.None));
+      AddVariableInfo(new VariableInfo("Sigma", "Parameter sigma of the normal distribution", typeof(DoubleData), VariableKind.In));
       GetVariableInfo("Sigma").Local = true;
       AddVariable(new Variable("Sigma", new DoubleData(1.0)));
 
-      AddVariableInfo(new VariableInfo("Value", "The value to manipulate (actual type is one of: IntData, DoubleData, ConstrainedIntData, ConstrainedDoubleData)", typeof(IObjectData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Value", "The value to manipulate (actual type is one of: IntData, DoubleData", typeof(IObjectData), VariableKind.In | VariableKind.Out));
+      AddVariableInfo(new VariableInfo("MinValue", "(optional) The minimal value", typeof(DoubleData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("MaxValue", "(optional) The maximal value", typeof(DoubleData), VariableKind.In));
       AddVariableInfo(new VariableInfo("ShakingFactor", "Determines the force of the shaking factor (effective sigma = sigma * shakingFactor)", typeof(DoubleData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Random", "The random generator to use", typeof(MersenneTwister), VariableKind.In));
@@ -94 +95 @@
       double mu = GetVariableValue<DoubleData>("Mu", scope, true).Data;
       double sigma = GetVariableValue<DoubleData>("Sigma", scope, true).Data;
+      DoubleData minValueData = GetVariableValue<DoubleData>("MinValue", scope, true, false);
+      double minValue = minValueData == null ? double.MinValue : minValueData.Data;
+      DoubleData maxValueData = GetVariableValue<DoubleData>("MaxValue", scope, true, false);
+      double maxValue = maxValueData == null ? double.MaxValue : maxValueData.Data;
+
       NormalDistributedRandom normal = new NormalDistributedRandom(mt, mu, sigma * factor);
 
-      AddNormal(value, normal);
+      AddNormal(value, normal, minValue, maxValue);
       return null;
     }
 
-    private void AddNormal(IObjectData value, NormalDistributedRandom normal) {
+    private void AddNormal(IObjectData value, NormalDistributedRandom normal, double minValue, double maxValue) {
       // dispatch manually based on dynamic type
       if (value is IntData)
-        AddNormal((IntData)value, normal);
-      else if (value is ConstrainedIntData)
-        AddNormal((ConstrainedIntData)value, normal);
-      else if (value is ConstrainedDoubleData)
-        AddNormal((ConstrainedDoubleData)value, normal);
+        AddNormal((IntData)value, normal, minValue, maxValue);
       else if (value is DoubleData)
-        AddNormal((DoubleData)value, normal);
+        AddNormal((DoubleData)value, normal, minValue, maxValue);
       else throw new InvalidOperationException("Can't handle type " + value.GetType().Name);
-    }
-    /// <summary>
-    /// Generates a new double random number and adds it to the value of 
-    /// the given <paramref name="data"/>.
-    /// </summary>
-    /// <param name="data">The double object where to add the random number.</param>
-    /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void AddNormal(DoubleData data, NormalDistributedRandom normal) {
-      data.Data += normal.NextDouble();
     }
 
@@ -128 +121 @@
     /// <exception cref="InvalidProgramException">Thrown when with the current settings no valid value
     /// could be found.</exception>
-    /// <param name="data">The double object where to add the random number and whose constraints
-    /// to fulfill.</param>
+    /// <param name="data">The double object where to add the random number</param>
     /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void AddNormal(ConstrainedDoubleData data, NormalDistributedRandom normal) {
+    /// <param name="minValue">The minimal value allowed for the double object.</param>
+    /// <param name="maxValue">The maximal value allowed for the double object.</param>
+    public void AddNormal(DoubleData data, NormalDistributedRandom normal, double minValue, double maxValue) {
       for (int tries = MAX_NUMBER_OF_TRIES; tries >= 0; tries--) {
         double newValue = data.Data + normal.NextDouble();
-        if (IsIntegerConstrained(data)) {
-          newValue = Math.Round(newValue);
-        }
-        if (data.TrySetData(newValue)) {
+        if (newValue >= minValue && newValue < maxValue) {
+          data.Data = newValue;
           return;
         }
       }
       throw new InvalidProgramException("Coudn't find a valid value");
-    }
-
-    /// <summary>
-    /// Generates a new int random number and adds it to value of the given <paramref name="data"/>.
-    /// </summary>
-    /// <param name="data">The int object where to add the random number.</param>
-    /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void AddNormal(IntData data, NormalDistributedRandom normal) {
-      data.Data = (int)Math.Round(data.Data + normal.NextDouble());
     }
 
@@ -159 +142 @@
     /// <exception cref="InvalidProgramException">Thrown when with the current settings no valid value 
     /// could be found.</exception>
-    /// <param name="data">The int object where to add the generated value and whose contraints to check.</param>
+    /// <param name="data">The int object where to add the generated value.</param>
     /// <param name="normal">The continuous, normally distributed random variable.</param>
-    public void AddNormal(ConstrainedIntData data, NormalDistributedRandom normal) {
+    /// <param name="minValue">The minimal value allowed for the double object.</param>
+    /// <param name="maxValue">The maximal value allowed for the double object.</param>
+    public void AddNormal(IntData data, NormalDistributedRandom normal, double minValue, double maxValue) {
       for (int tries = MAX_NUMBER_OF_TRIES; tries >= 0; tries--) {
-        if (data.TrySetData((int)Math.Round(data.Data + normal.NextDouble())))
+        int newValue = (int)Math.Round(data.Data + normal.NextDouble());
+        if (newValue >= minValue && newValue < maxValue) {
+          data.Data = newValue;
           return;
+        }
       }
       throw new InvalidProgramException("Couldn't find a valid value.");
     }
-
-    private bool IsIntegerConstrained(ConstrainedDoubleData data) {
-      foreach (IConstraint constraint in data.Constraints) {
-        if (constraint is IsIntegerConstraint) {
-          return true;
-        }
-      }
-      return false;
-    }
   }
 }