source: branches/2971_named_intervals/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraint.cs @ 17506

#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 HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;

namespace HeuristicLab.Problems.DataAnalysis {
  [StorableType("8109BE58-CCFB-4462-A2F4-EEE5DFADAFF7")]
  [Item("Interval Constraint", "Constraint on intervals.")]
  public sealed class IntervalConstraint : Item {
    [Storable]
    private string expression;
    public string Expression {
      get => expression;
      private set {
        if (expression == value) return;
        expression = value;
        OnChanged();
        OnToStringChanged();
      }
    }

    public string Definition {
      get { return GetDefinitionString(); }
    }

    [Storable]
    private string variable;
    public string Variable {
      get => variable;
      private set {
        if (variable == value) return;
        variable = value;
        UpdateExpression();
        OnChanged();
      }
    }

    [Storable]
    private string target;
    public string Target {
      get => target;
      private set {
        if (target == value) return;
        target = value;
        UpdateExpression();
        OnChanged();
      }
    }

    public bool IsDerivative {
      get => NumberOfDerivations > 0;
    }

    [Storable]
    private int numberOfDerivations;
    public int NumberOfDerivations {
      get => numberOfDerivations;
      set {
        if (value < 0 || value > 3) throw new ArgumentException("Number of derivation has to be between 0 - 3.");
        if (numberOfDerivations == value) return;
        numberOfDerivations = value;
        UpdateExpression();
        OnChanged();
      }
    }

    [Storable]
    private Interval interval;
    public Interval Interval {
      get => interval;
      set {
        if (interval == value) return;
        interval = value;
        UpdateExpression();
        OnChanged();
      }
    }

    [Storable]
    private bool enabled;
    public bool Enabled {
      get => enabled;
      set {
        if (enabled == value) return;
        enabled = value;
        OnChanged();
      }
    }

    [StorableConstructor]
    private IntervalConstraint(StorableConstructorFlag _) : base(_) { }

    public IntervalConstraint(string expression, string variable, string target, int numberOfDerivations, Interval interval, bool enabled) : base(){
      this.expression = expression;
      this.variable = variable;
      this.target = target;
      this.numberOfDerivations = numberOfDerivations;
      this.interval = interval;
      this.enabled = enabled;
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new IntervalConstraint(this, cloner);
    }

    private IntervalConstraint(IntervalConstraint original, Cloner cloner)
      : base(original, cloner) {
      this.Expression = original.Expression;
      this.Variable = original.Variable;
      this.Target = original.Target;
      this.NumberOfDerivations = original.NumberOfDerivations;
      this.Interval = original.Interval;
      this.Enabled = original.Enabled;
    }

    public event EventHandler Changed;
    private void OnChanged() {
      EventHandler handlers = Changed;
      if (handlers != null)
        handlers(this, EventArgs.Empty);
    }

    private static string GetDerivationString(int derivation) {
      switch (derivation) {
        case 1:
          return "";
        case 2:
          return "²";
        case 3:
          return "³";
        default:
          return "";
      }
    }

    private void UpdateExpression() {
      var expression = "";

      if (!IsDerivative) {
        expression = string.Format("Target:{0} in {1}{2} .. {3}{4}",
          Variable,
          "[",
          Interval?.LowerBound,
          Interval?.UpperBound,
          "]");
        Expression = expression;
        return;
      } 
      expression = string.Format("∂{6}{1}/∂{0}{6} in {2}{3} .. {4}{5}",
        Variable,
        Target,
        "[",
        Interval?.LowerBound,
        Interval?.UpperBound,
        "]",
        GetDerivationString(numberOfDerivations));
        Expression = expression;
    }

    private string GetDefinitionString() {
      if (!IsDerivative) {
        return "Target " + Variable;
      }
      var definition = $"∂{GetDerivationString(numberOfDerivations)}Target/∂{Variable}{GetDerivationString(numberOfDerivations)}";
      return definition;
    }

    public override string ToString() {
      return Expression;
    }
  }
}