Changeset 17723 for branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval

Timestamp:

08/11/20 14:22:45 (4 years ago)

Author:

dpiringe

Message:

#3073

• added regions in IntervalConstraint
• modified IntervalConstraintsParser to detect regions

Location:

branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval

Files:

• IntervalConstraint.cs (modified) (5 diffs)
• IntervalConstraintsParser.cs (modified) (4 diffs)

branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraint.cs

@@ -22 +22 @@
 #endregion
 using System;
+using System.Collections.Generic;
 using HEAL.Attic;
 using HeuristicLab.Common;
@@ -113 +114 @@
     }
 
+    [Storable]
+    private IDictionary<string, Interval> regions = new Dictionary<string, Interval>();
+    public IDictionary<string, Interval> Regions
+    {
+      get => regions;
+      set
+      {
+        if (regions != value)
+        {
+          regions = value;
+          UpdateExpression();
+          OnChanged();
+        }
+      }
+    }
+
     [StorableConstructor]
     private IntervalConstraint(StorableConstructorFlag _) : base(_) { }
 
     public IntervalConstraint(string   expression, string variable, string target, int numberOfDerivations,
-                              Interval interval,   bool   enabled) {
-      this.expression          = expression;
-      this.variable            = variable;
-      this.target              = target;
+                              Interval interval,   bool   enabled) 
+      : this(expression, variable, target, numberOfDerivations, 
+             interval, new Dictionary<string, Interval>(), enabled) { }
+
+    public IntervalConstraint(string expression, string variable, string target, int numberOfDerivations,
+                              Interval interval, IDictionary<string, Interval> regions, bool enabled)
+    {
+      this.expression = expression;
+      this.variable = variable;
+      this.target = target;
       this.numberOfDerivations = numberOfDerivations;
-      this.interval            = interval;
-      this.enabled             = enabled;
+      this.interval = interval;
+      this.regions = regions;
+      this.enabled = enabled;
     }
 
@@ -137 +161 @@
       NumberOfDerivations = original.NumberOfDerivations;
       Interval            = original.Interval;
+      Regions             = original.Regions;
       Enabled             = original.Enabled;
     }
@@ -171 +196 @@
                                    Interval?.UpperBound,
                                    "]");
+        foreach(var kvp in Regions)
+          expression += $", {kvp.Key}=({kvp.Value.LowerBound} .. {kvp.Value.UpperBound})";
         Expression = expression;
         return;
@@ -183 +210 @@
                                  "]",
                                  GetDerivationString(numberOfDerivations));
+      foreach (var kvp in Regions)
+        expression += $", {kvp.Key}=({kvp.Value.LowerBound} .. {kvp.Value.UpperBound})";
       Expression = expression;
     }

branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraintsParser.cs

@@ -45 +45 @@
           var end              = trimmedLine.Length;
           var targetConstraint = trimmedLine.Substring(start, end - start);
-          var match = Regex.Match(targetConstraint,
-                                  @"(['](.*)[']|(.*[^\s]))\s*(\bin\b)\s*([\[])\s*(\S*)\s*(\.{2})\s*(\S*)\s*([\]])");
+
+          var match = 
+          Regex.Match(targetConstraint,
+                        @"(['](.*)[']|(.*[^\s]))" +
+                        @"\s*(\bin\b)" +
+                        @"\s*([\[])" +
+                        @"\s*(\S*)" + // 6: interval lower bound
+                        @"\s*(\.{2})" +
+                        @"\s*(\S*)" + // 8: interval upper bound
+                        @"\s*([\]])" +
+                        @"(" +
+                          @"\s*,\s*(\S*)\s*=\s*" + // 11: variable name
+                          @"([(])\s*" +
+                          @"(\S*)\s*" + // 13: region lower bound
+                          @"(\.{2})\s*" +
+                          @"(\S*)\s*" + // 15: region upper bound
+                          @"([)])" +
+                        @")*");
+          
           if (match.Success) {
-            if (match.Groups.Count != 10) throw new ArgumentException("The target-constraint is not complete.", line);
+            if (match.Groups.Count < 9) throw new ArgumentException("The target-constraint is not complete.", line);
 
             var targetVariable = match.Groups[1].Value.Trim();
-            if (match.Groups[1].Value.Trim().StartsWith("'") && match.Groups[1].Value.Trim().EndsWith("'"))
+            if (targetVariable.StartsWith("'") && targetVariable.EndsWith("'"))
               targetVariable = targetVariable.Substring(1, targetVariable.Length - 2);
 
@@ -68 +85 @@
             var interval           = new Interval(lowerBound, upperBound);
 
-            var constraint =
-              new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
-
-            yield return constraint;
+            if (match.Groups[10].Success)
+            {
+              IDictionary<string, Interval> pairs = new Dictionary<string, Interval>();
+              // option variables found
+              for(int idx = 0; idx < match.Groups[10].Captures.Count; ++idx)
+              {
+                var inputVar = match.Groups[11].Captures[idx].Value;
+                var regionLb = ParseIntervalBounds(match.Groups[13].Captures[idx].Value);
+                var regionUb = ParseIntervalBounds(match.Groups[15].Captures[idx].Value);
+                pairs.Add(inputVar, new Interval(regionLb, regionUb));
+              }
+              yield return new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, pairs, isEnabled);
+            }
+            else
+            {
+              yield return new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
+            }
           }
           else {
@@ -80 +110 @@
         }
         else if (trimmedLine.StartsWith("d") || trimmedLine.StartsWith("\u2202")) {
-          var match = Regex.Match(trimmedLine,
-                                  @"([d∂])([²³]?)\s*(['](.*)[']|(.*[^\s]))\s*(\/)\s*([d∂])\s*(['](.*)[']|(.*[^\s²³]))\s*([²³]?)\s*\bin\b\s*([\[])\s*(\S*)\s*(\.{2})\s*(\S*)\s*([\]])");
+          var match = Regex.Match(trimmedLine, 
+                                    @"([d∂])" +
+                                    @"([²³]?)\s*" +
+                                    @"(['](.*)[']|(.*[^\s]))\s*" +
+                                    @"(\/)\s*" +
+                                    @"([d∂])\s*" +
+                                    @"(['](.*)[']|(.*[^\s²³]))\s*" +
+                                    @"([²³]?)\s*\bin\b\s*" +
+                                    @"([\[])\s*" +
+                                    @"(\S*)\s*" +
+                                    @"(\.{2})\s*" +
+                                    @"(\S*)\s*" +
+                                    @"([\]])" +
+                                    @"(" +
+                                      @"\s*,\s*(\S*)\s*=\s*" + // 18: variable name
+                                      @"([(])\s*" +
+                                      @"(\S*)\s*" + // 20: region lower bound
+                                      @"(\.{2})\s*" +
+                                      @"(\S*)\s*" + // 22: region upper bound
+                                      @"([)])" +
+                                    @")*");
 
           if (match.Success) {
-            if (match.Groups.Count != 17)
+            if (match.Groups.Count < 24)
               throw new ArgumentException("The given derivation-constraint is not complete.", line);
 
@@ -121 +170 @@
             var interval           = new Interval(lowerBound, upperBound);
 
-            var constraint =
-              new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
-
-            yield return constraint;
+            if(match.Groups[17].Success)
+            {
+              IDictionary<string, Interval> pairs = new Dictionary<string, Interval>();
+              // option variables found
+              for (int idx = 0; idx < match.Groups[17].Captures.Count; ++idx)
+              {
+                var inputVar = match.Groups[18].Captures[idx].Value;
+                var regionLb = ParseIntervalBounds(match.Groups[20].Captures[idx].Value);
+                var regionUb = ParseIntervalBounds(match.Groups[22].Captures[idx].Value);
+                pairs.Add(inputVar, new Interval(regionLb, regionUb));
+              }
+              yield return new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, pairs, isEnabled);
+            } else {
+              yield return new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
+            }
           }
           else {