source: branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs @ 17887

#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("ShapeConstraint", "Constraint on the shape of a function e.g. monotonicity.")]
  public sealed class ShapeConstraint : Item {
    // [Storable]
    // private string expression;
    // 
    // public string Expression {
    //   get => expression;
    //   private set {
    //     if (expression == value)
    //       return;
    //     expression = value;
    //     OnChanged();
    //     OnToStringChanged();
    //   }
    // }

    // public string Definition => GetDefinitionString();

    [Storable]
    private string variable;

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

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

    public bool IsDerivative => 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;
        OnChanged();
      }
    }

    [Storable]
    private Interval interval;

    public Interval Interval {
      get => interval;
      set {
        if (interval == value)
          return;
        interval = value;
        OnChanged();
      }
    }

    [Storable]
    private bool enabled;

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

    [Storable]
    private IntervalCollection regions;
    public IntervalCollection Regions {
      get => regions;
      set {
        if (regions != value) {
          regions = value;
          OnChanged();
        }
      }
    }

    [Storable]
    private double weight = 1.0;
    public double Weight {
      get => weight;
      set {
        if (weight != value) {
          weight = value;
          OnChanged();
        }
      }
    }

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

    // without derivation
    public ShapeConstraint(Interval interval, double weight, bool enabled)
      : this(string.Empty, 0,
         interval, new IntervalCollection(), weight, enabled) { }

    public ShapeConstraint(Interval interval, IntervalCollection regions, double weight, bool enabled)
      : this(string.Empty, 0,
         interval, regions, weight, enabled) { }

    public ShapeConstraint(string variable, int numberOfDerivations,
                              Interval interval, double weight, bool enabled)
      : this(variable, numberOfDerivations,
             interval, new IntervalCollection(), weight, enabled) { }

    public ShapeConstraint(string variable, int numberOfDerivations,
                              Interval interval, IntervalCollection regions, double weight, bool enabled) {
      this.regions = regions;
      this.weight = weight;
      this.variable = variable;
      this.numberOfDerivations = numberOfDerivations;
      this.interval = interval;
      this.enabled = enabled;
    }

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

    private ShapeConstraint(ShapeConstraint original, Cloner cloner)
      : base(original, cloner) {
      Regions = original.Regions;
      Variable = original.Variable;
      NumberOfDerivations = original.NumberOfDerivations;
      Interval = original.Interval;
      Enabled = original.Enabled;
    }

    public event EventHandler Changed;

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


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

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


    private string GenerateExpressionString() {
      string expression;

      if (!IsDerivative) {
        expression = string.Format($"f in [{Interval?.LowerBound} .. {Interval?.UpperBound}]");
        if (Regions != null) {
          foreach (var region in Regions.GetReadonlyDictionary())
            expression += $", {region.Key}=({region.Value.LowerBound} .. {region.Value.UpperBound})";
        }

        return expression;
      }

      var derivationString = string.Empty;
      switch (numberOfDerivations) {
        case 1:
          derivationString = ""; break;
        case 2:
          derivationString = "²"; break;
        case 3:
          derivationString = "³"; break;
      }
      expression = string.Format($"∂{derivationString}f/∂{Variable}{derivationString} in [{Interval?.LowerBound} .. {Interval?.UpperBound}]");
      if (Regions != null) {
        foreach (var region in Regions.GetReadonlyDictionary())
          expression += $", {region.Key}=({region.Value.LowerBound} .. {region.Value.UpperBound})";
      }
      return expression;
    }
  }
}