source: branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/RescaleTransformation.cs @ 15938

// #region License Information
// /* HeuristicLab
//  * Copyright (C) 2002-2018 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.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.DataAnalysis {
  [Item("Rescale", "Rescale the data to a given range (e.g. [0-1]).")]
  [StorableClass]
  public class RescaleTransformation : Transformation<double> {

    #region Parameters
    private IFixedValueParameter<DoubleRange> TargetRangeParameter {
      get { return (IFixedValueParameter<DoubleRange>)Parameters["Target Range"]; }
    }
    private IFixedValueParameter<DoubleRange> OriginalRangeParameter {
      get { return (IFixedValueParameter<DoubleRange>)Parameters["Original Range"]; }
    }
    #endregion

    #region Properties
    public double TargetMin {
      get { return TargetRangeParameter.Value.Start; }
      set { TargetRangeParameter.Value.Start = value; }
    }
    public double TargetMax {
      get { return TargetRangeParameter.Value.End; }
      set { TargetRangeParameter.Value.End = value; }
    }
    public double OriginalMin {
      get { return OriginalRangeParameter.Value.Start; }
      private set { OriginalRangeParameter.Value.Start = value; }
    }
    public double OriginalMax {
      get { return OriginalRangeParameter.Value.End; }
      private set { OriginalRangeParameter.Value.End = value; }
    }
    #endregion

    #region Constructor, Cloning & Persistence
    public RescaleTransformation()
      : base() {
      Parameters.Add(new FixedValueParameter<DoubleRange>("Target Range", new DoubleRange(0.0, 1.0)));
      Parameters.Add(new FixedValueParameter<DoubleRange>("Original Range", new DoubleRange(double.NaN, double.NaN)) { Hidden = true });
    }

    protected RescaleTransformation(RescaleTransformation original, Cloner cloner)
      : base(original, cloner) {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new RescaleTransformation(this, cloner);
    }

    [StorableConstructor]
    protected RescaleTransformation(bool deserializing)
      : base(deserializing) {
    }
    #endregion

    public override bool Check(IEnumerable<double> data, out string errorMessage) {
      if (data.StandardDeviationPop().IsAlmost(0.0)) {
        errorMessage = "Rescaling cannot be applied for data with a standard deviation of zero.";
        return false;
      }
      return base.Check(data, out errorMessage);
    }

    public override void Configure(IEnumerable<double> data) {
      Configure(data, out double originalMin, out double originalMax);
      OriginalMin = originalMin;
      OriginalMax = originalMax;
      base.Configure(data);
    }

    public override IEnumerable<double> Apply(IEnumerable<double> data) {
      if (double.IsNaN(OriginalMin) || double.IsNaN(OriginalMax))
        throw new InvalidOperationException("Transformation is not configured");

      return Apply(data, TargetMin, TargetMax, OriginalMin, OriginalMax);
    }

    public override IEnumerable<double> InverseApply(IEnumerable<double> data) {
      if (double.IsNaN(OriginalMin) || double.IsNaN(OriginalMax))
        throw new InvalidOperationException("Transformation is not configured");

      return InverseApply(data, TargetMin, TargetMax, OriginalMin, OriginalMax);
    }


    public static void Configure(IEnumerable<double> data, out double originalMin, out double originalMax) {
      originalMin = data.Min();
      originalMax = data.Max();
    }

    public static IEnumerable<double> Apply(IEnumerable<double> data, double targetMin, double targetMax, double originalMin = double.NaN, double originalMax = double.NaN) {
      if (double.IsNaN(originalMin)) originalMin = data.Min();
      if (double.IsNaN(originalMax)) originalMax = data.Max();

      GetLinearTransformationParameters(targetMin, targetMax, originalMin, originalMax, out double scale, out double offset);

      return LinearTransformation.Apply(data, scale, offset);
    }

    public static IEnumerable<double> InverseApply(IEnumerable<double> data, double targetMin, double targetMax, double originalMin, double originalMax) {
      GetLinearTransformationParameters(targetMin, targetMax, originalMin, originalMax, out double scale, out double offset);

      return LinearTransformation.InverseApply(data, scale, offset);
    }

    private static void GetLinearTransformationParameters(double targetMin, double targetMax, double originalMin, double originalMax,
        out double scale, out double offset) {
      var originalRange = originalMax - originalMin;
      var targetRange = targetMax - targetMin;

      scale = targetRange / originalRange;
      offset = targetMin - originalMin * scale;
    }
  }
}