source: branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs @ 17768

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  public static class IntervalUtil {
    public static double IntervalConstraintViolation(
      IntervalConstraint constraint, IBoundsEstimator estimator, IntervalCollection intervalCollection,
      ISymbolicExpressionTree solution) {
      var variableRanges = intervalCollection.GetReadonlyDictionary();

      if (constraint.Variable != null && !variableRanges.ContainsKey(constraint.Variable)) {
        throw new ArgumentException(
          $"The given variable {constraint.Variable} in the constraint does not exist in the model.",
          nameof(IntervalConstraintsParser));
      }

      //Create new variable ranges for defined regions
      var regionRanges = new IntervalCollection();
      foreach (var kvp in variableRanges) {
        if (kvp.Key != constraint.Target && constraint.Regions.GetReadonlyDictionary().TryGetValue(kvp.Key, out Interval val)) {
          regionRanges.AddInterval(kvp.Key, val);
        } else {
          regionRanges.AddInterval(kvp.Key, kvp.Value);
        }
      }

      var error = 0.0;
      if (!constraint.IsDerivative) {
        error = estimator.CheckConstraint(solution, regionRanges, constraint);
      } else {
        var tree = solution;
        for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
          if (!estimator.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree)) {
            throw new ArgumentException("Cube, Root, Power symbols are not supported.");
          }

          tree = DerivativeCalculator.Derive(tree, constraint.Variable);
        }

        error = estimator.CheckConstraint(tree, regionRanges, constraint);
      }

      return error * constraint.Weight;
      //Interval resultInterval;
      //if (!constraint.IsDerivative) {
      //  resultInterval = estimator.GetModelBound(solution, regionRanges);
      //} else {
      //  var tree = solution;
      //  for (var i = 0; i < constraint.NumberOfDerivations; ++i) {
      //    if (!estimator.IsCompatible(tree) || !DerivativeCalculator.IsCompatible(tree)) {
      //      throw new ArgumentException("Cube, Root, Power symbols are not supported.");
      //    }

      //    tree = DerivativeCalculator.Derive(tree, constraint.Variable);
      //  }

      //  resultInterval = estimator.GetModelBound(tree, regionRanges);
      //}

      //var error = 0.0;

      //if (!constraint.Interval.Contains(resultInterval.LowerBound)) {
      //  error     += Math.Abs(resultInterval.LowerBound - constraint.Interval.LowerBound);
      //}

      //if (!constraint.Interval.Contains(resultInterval.UpperBound)) {
      //  error     += Math.Abs(resultInterval.UpperBound - constraint.Interval.UpperBound);
      //}

      //error *= constraint.Weight;

      //return error;
    }

    public static IEnumerable<double> IntervalConstraintsViolation(
      IEnumerable<IntervalConstraint> constraints, IBoundsEstimator estimator, IntervalCollection intervalCollection,
      ISymbolicExpressionTree solution) {
      return constraints
            .Select(constraint => IntervalConstraintViolation(constraint, estimator, intervalCollection, solution))
            .ToList();
    }
  }
}