source: branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Parser/IntervalConstraintsParser.cs @ 16879

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;

namespace HeuristicLab.Problems.DataAnalysis {
  public static class IntervalConstraintsParser {

    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*(\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("Target:" + match.Groups[0].Value);
              constraint.Expression = "Target:" + match.Groups[0].Value;
              constraint.Definition = "Target " + match.Groups[1].Value.Trim();
              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*([²³]?)\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.Trim());
              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
          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();
      switch (input) {
        case "+inf.":
        case "inf.":
          return double.PositiveInfinity;
        case "-inf.":
          return double.NegativeInfinity;
        default: {
            if (double.TryParse(input, NumberStyles.Any, CultureInfo.InvariantCulture, out var value)) {
              return value;
            } else {
              throw new ArgumentException("The given boundary is not a double value!");
            }
          }
      }
    }

    private static int ParseDerivationCount(string input) {
      switch (input) {
        case "":
          return 1;
        case "²":
          return 2;
        case "³":
          return 3;
        default:
          int.TryParse(input, out var value);
          return value;
      }
    }
  }
}