Changeset 16773 for branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser

Timestamp:

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

Author:

chaider

Message:

#2971

• Fixes and updates in IntervalConstraintView
• Changed Parser

Location:

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

Files:

• IntervalConstraint.cs (modified) (2 diffs)
• IntervalConstraintsParser.cs (modified) (3 diffs)

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!");
             }
           }