Changeset 16773

Timestamp:

04/09/19 14:58:24 (5 years ago)

Author:

chaider

Message:

#2971

• Fixes and updates in IntervalConstraintView
• Changed Parser

Location:

branches/2971_named_intervals

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionConstraintAnalyzer.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/ParsedConstraintView.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraint.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraintsParser.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/ParsedConstraint.cs (modified) (3 diffs)

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionConstraintAnalyzer.cs

@@ -85 +85 @@
     }
 
-    static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicExpressionTree model,
+    public static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicExpressionTree model,
       IRegressionProblemData problemData) {
-      //var constraints = IntervalConstraintsParser.Parse(((RegressionProblemData)problemData).IntervalConstraints.Value);
       var constraints = ((RegressionProblemData)problemData).IntervalConstraintsParameter.Value.Constraints;
       var constraintViolations = new Dictionary<IntervalConstraint, bool>();
@@ -101 +100 @@
     }
 
-    static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicRegressionModel model,
+    public static Dictionary<IntervalConstraint, bool> CheckConstraints(ISymbolicRegressionModel model,
       IRegressionProblemData problemData) {
       return CheckConstraints(model.SymbolicExpressionTree, problemData);
     }
 
-    static bool CheckConstraint(ISymbolicExpressionTree model, Dictionary<string, Interval> variableRanges,
+    public static bool CheckConstraint(ISymbolicExpressionTree model, Dictionary<string, Interval> variableRanges,
       IntervalConstraint constraint) {
       var intervalInterpreter = new IntervalInterpreter();
@@ -148 +147 @@
       var constraintViolations = new Dictionary<string, int>();
 
-      //var constraints = IntervalConstraintsParser.Parse(problemData.IntervalConstraints.Value);
       var constraints = problemData.IntervalConstraintsParameter.Value.Constraints;
 

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis.Views/3.4/ParsedConstraintView.cs

@@ -1 +1 @@
 using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Drawing;
-using System.Data;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Forms;
+
 using HeuristicLab.Core;
 using HeuristicLab.MainForm;
@@ -21 +14 @@
       set => base.Content = value;
     }
+
     public ParsedConstraintView() {
       InitializeComponent();
@@ -38 +32 @@
 
     private ItemList<IntervalConstraint> ParseConstraints(string input) {
-      ItemList<IntervalConstraint> constraints = new ItemList<IntervalConstraint>(IntervalConstraintsParser.Parse(input));
+      ItemList<IntervalConstraint> constraints = new ItemList<IntervalConstraint>(IntervalConstraintsParser.ParseInput(input, Content.TargetVariable, Content.AllowedVariables));
       return constraints;
-    }
-
-    private string ConstraintsOutput(IEnumerable<IntervalConstraint> constraints) {
-      var result = "";
-      var count = 1;
-      foreach (var constraint in constraints) {
-        result += "Constraint #" + count + ": " + Environment.NewLine;
-        result += constraint.Expression + Environment.NewLine + Environment.NewLine;
-        count++;
-      }
-
-      return result;
     }
 

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraint.cs

@@ -11 +11 @@
   [StorableType("8109BE58-CCFB-4462-A2F4-EEE5DFADAFF7")]
   [Item("Interval Constraint", "Constraint on intervals.")]
-  public class IntervalConstraint : Item {
+  public class IntervalConstraint : NamedItem {
     public string Expression { get; set; }
     public string Definition { get; set; }
@@ -23 +23 @@
     public IntervalConstraint() {}
 
+    public IntervalConstraint(string name) {
+      base.name = name;
+    }
+
     public IntervalConstraint(string expression, string definition, Interval interval, bool inclusiveLowerBound,
       bool inclusiveUpperBound, bool isDerivation, string variable, int numberOfDerivation) {
+      base.name = expression;
       Expression = expression;
       Definition = definition;

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraintsParser.cs

@@ -2 +2 @@
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using System.Text.RegularExpressions;
 
@@ -46 +47 @@
     }
 
+    public static IEnumerable<IntervalConstraint> ParseInput(string input, string target = "", IEnumerable<string> variables = null) {
+      var lines = input.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
+      foreach (var line in lines) {
+        var trimmedLine = line.TrimStart();
+        //Check for target-variable constraint
+        if (trimmedLine.StartsWith("Target:")) {
+          var start = "Target:".Length;
+          var end = trimmedLine.Length;
+          var targetConstraint = trimmedLine.Substring(start, end-start);
+          var match = Regex.Match(targetConstraint,
+            @"([^\s]*)\s*(\bin\b)\s*([\[\]])\s*(\S*)\s*(..)\s*(\S*)\s*([\[\]])");
+          if (match.Success) {
+            if (match.Groups.Count != 8) {
+              throw new ArgumentException("The given target-constraint is not complete!");
+            } else {
+              if (target != "") {
+                if (match.Groups[1].Value.Trim() != target) {
+                  throw new ArgumentException("The given target variable is not in the given dataset!");
+                }
+              }
+              var lowerBound = ParseIntervalBounds(match.Groups[4].Value);
+              var upperBound = ParseIntervalBounds(match.Groups[6].Value);
+              var constraint = new IntervalConstraint(match.Groups[0].Value);
+              constraint.Expression = match.Groups[0].Value;
+              constraint.Definition = "";
+              constraint.Variable = match.Groups[1].Value.Trim();
+              constraint.InclusiveLowerBound = match.Groups[3].Value.Trim() == "[";
+              constraint.InclusiveUpperBound = match.Groups[7].Value.Trim() == "]";
+              constraint.IsDerivation = false;
+              constraint.NumberOfDerivation = 0;
+              constraint.Interval = new Interval(lowerBound, upperBound);
+
+              yield return constraint;
+            }
+          } else {
+            throw new ArgumentException("The inserted target constraint is not valid!");
+          }
+          //Check for derivation
+        } else if (trimmedLine.StartsWith("d") || trimmedLine.StartsWith("\u2202")) {
+          var match = Regex.Match(trimmedLine,
+            @"([d∂])([²³])?\s*(\S*)\s*(\/)([d∂])\s*([^²³]*)([²³])?\s*\bin\b\s*([\[\]])\s*(\S*)\s*(..)\s*(\S*)\s*([\[\]])");
+
+          if (match.Success) {
+            if (match.Groups.Count != 13) {
+              throw new ArgumentException("The given derivation-constraint is not complete");
+            } else {
+              if (target != "") {
+                if (match.Groups[3].Value != target) 
+                  throw new ArgumentException("The given target variable is not given in the dataset!");
+              }
+
+              if (variables != null && variables.Any()) {
+                if (variables.All(v => v != match.Groups[6].Value.Trim())) {
+                  throw new ArgumentException("The given variable does not exist in the dataset!");
+                }
+              }
+
+              if (match.Groups[2].Value.Trim() != "" || match.Groups[7].Value.Trim() != "") {
+                if (match.Groups[2].Value.Trim() == "" || match.Groups[7].Value.Trim() == "")
+                  throw new ArgumentException("Number of derivation has to be written on both sides!");
+                if (match.Groups[2].Value.Trim() != match.Groups[7].Value.Trim())
+                  throw new ArgumentException("Derivation number is not equal on both sides!");
+              }
+
+              var lowerBound = ParseIntervalBounds(match.Groups[9].Value);
+              var upperBound = ParseIntervalBounds(match.Groups[11].Value);
+              var constraint = new IntervalConstraint(match.Groups[0].Value);
+              constraint.Expression = match.Groups[0].Value;
+              constraint.Definition = match.Groups[1].Value + match.Groups[2].Value + match.Groups[3].Value +
+                                      match.Groups[4].Value + match.Groups[5].Value + match.Groups[6].Value + match.Groups[7].Value;
+              constraint.IsDerivation = true;
+              constraint.InclusiveLowerBound = match.Groups[8].Value.Trim() == "[";
+              constraint.InclusiveUpperBound = match.Groups[12].Value.Trim() == "]";
+              constraint.Variable = match.Groups[6].Value.Trim();
+              constraint.NumberOfDerivation = ParseDerivationCount(match.Groups[2].Value);
+              constraint.Interval = new Interval(lowerBound, upperBound);
+
+              yield return constraint;
+            }
+          } else {
+            throw new ArgumentException("The inserted derivation constraint is not valid!");
+          }
+          //Check for comment
+        } else if (trimmedLine.StartsWith("#") || trimmedLine == "") {
+          //If it is a comment just continue without saving anything
+          //TODO maybe save comment too.
+          continue;
+        } else {
+          throw new ArgumentException("Error at your constraints definition constraints have to start with Target: | d | \u2202 | #");
+        }
+      }
+    }
+
     private static double ParseIntervalBounds(string input) {
       input = input.ToLower();
@@ -58 +152 @@
               return value;
             } else {
-              throw new ArgumentException("The given Interval in the constraint is not valid.");
+              throw new ArgumentException("The given boundary is not a double value!");
             }
           }

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

@@ -165 +165 @@
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
-
+      
       NamedIntervals namedIntervals = new NamedIntervals();
       foreach (var variable in variables) {
@@ -172 +172 @@
         namedIntervals.Add(variable.Value, variableInterval);
       }
-
+      
       var commentMessage = "#Example of a target variable constraint" + Environment.NewLine +
                            "#F1: TargetVariable" + Environment.NewLine +
@@ -181 +181 @@
                            "#double: upperbound of the interval" + Environment.NewLine +
                            "#bracket: open or closed regarding to open or closed interval definition" + Environment.NewLine +
-                           "#F1 in [0 .. 1.2]" + Environment.NewLine + Environment.NewLine +
+                           "#Y2 in [0 .. 1.2]" + Environment.NewLine + Environment.NewLine +
                            "#Constraints on model parameters:" + Environment.NewLine +
                            "#derivation symbol: d or ∂" + Environment.NewLine +
                            "#derivation in leibniz notation" + Environment.NewLine +
                            "#in and interval syntax is the same like above" + Environment.NewLine +
-                           "#∂F2/∂X1 in [0 .. inf.[" + Environment.NewLine +
-                           "#∂²F2/∂X1² in [0 .. inf.[" + Environment.NewLine +
-                           "#∂F2/∂X9 in [-100 .. 0]" + Environment.NewLine +
-                           "#∂²F2/∂X9² in [0 .. inf.[";
+                           "#∂Y2/∂X1 in [0 .. inf.[" + Environment.NewLine +
+                           "#∂²Y2/∂X1² in [0 .. inf.[" + Environment.NewLine +
+                           "#∂Y2/∂X9 in [-100 .. 0]" + Environment.NewLine +
+                           "#∂²Y2/∂X9² in [0 .. inf.[";
 
       Parameters.Add(new FixedValueParameter<NamedIntervals>(VariableRangesParameterName, namedIntervals));
-      Parameters.Add(new FixedValueParameter<ParsedConstraint>(IntervalConstraintsParameterName, new ParsedConstraint(commentMessage)));
+      Parameters.Add(new FixedValueParameter<ParsedConstraint>(IntervalConstraintsParameterName, new ParsedConstraint(commentMessage, targetVariable, allowedInputVariables)));
       RegisterParameterEvents();
     }

branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/ParsedConstraint.cs

@@ -5 +5 @@
 using System.Text;
 using System.Threading.Tasks;
+using System.Windows.Markup;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -26 +28 @@
     }
 
+    protected string targetVariable;
+    public string TargetVariable {
+      get => targetVariable;
+      set => targetVariable = value;
+    }
+
+    protected IEnumerable<string> allowedVariables;
+
+    public IEnumerable<string> AllowedVariables {
+      get => allowedVariables;
+      set => allowedVariables = value;
+    }
+
     protected ParsedConstraint(ParsedConstraint original, Cloner cloner)
       : base(original, cloner) {
       this.input = original.Input ?? string.Empty;
       this.constraints = original.Constraints ?? new ItemList<IntervalConstraint>();
+      
     }
 
@@ -41 +57 @@
     }
 
-    public ParsedConstraint(string input) {
+    public ParsedConstraint(string input, string targetVariable, IEnumerable<string> allowedVariables) {
       this.input = input;
       this.constraints = new ItemList<IntervalConstraint>();
+      this.targetVariable = targetVariable;
+      this.allowedVariables = allowedVariables;
     }