source: branches/DataPreprocessing Cleanup/HeuristicLab.DataPreprocessing/3.4/Data/Columns/PreprocessingDataColumn.cs @ 15309

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 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.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.DataPreprocessing {
  [Item("PreprocessingDataColumn", "")]
  [StorableClass]
  public abstract class PreprocessingDataColumn : NamedItem {

    #region Constructor, Cloning & Persistence
    protected PreprocessingDataColumn() {
    }
    protected PreprocessingDataColumn(string name)
      : base(name) {
    }

    protected PreprocessingDataColumn(PreprocessingDataColumn original, Cloner cloner)
      : base(original, cloner) {
    }

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

    public abstract int Length { get; }
    public abstract Type GetValueType();
    public virtual bool IsType<T>() { return GetValueType() == typeof(T); }

    public abstract bool IsValidValue(int index);

    #region Column Type Switches
    internal void TypeSwitch(Action<DoublePreprocessingDataColumn> doubleAction, Action<StringPreprocessingDataColumn> stringAction = null, Action<DateTimePreprocessingDataColumn> dateTimeAction = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleAction != null) doubleAction(doubleColumn);
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringAction != null) stringAction(stringColumn);
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeAction != null) dateTimeAction(dateTimeColumn);
    }
    internal void TypeSwitch<TIn>(TIn value, Action<DoublePreprocessingDataColumn, double> doubleAction, Action<StringPreprocessingDataColumn, string> stringAction = null, Action<DateTimePreprocessingDataColumn, DateTime> dateTimeAction = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleAction != null) doubleAction(doubleColumn, Convert<double>(value));
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringAction != null) stringAction(stringColumn, Convert<string>(value));
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeAction != null) dateTimeAction(dateTimeColumn, Convert<DateTime>(value));
    }

    internal TOut TypeSwitch<TOut>(Func<DoublePreprocessingDataColumn, double> doubleFunc, Func<StringPreprocessingDataColumn, string> stringFunc = null, Func<DateTimePreprocessingDataColumn, DateTime> dateTimeFunc = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleFunc != null) return Convert<TOut>(doubleFunc(doubleColumn));
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringFunc != null) return Convert<TOut>(stringFunc(stringColumn));
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeFunc != null) return Convert<TOut>(dateTimeFunc(dateTimeColumn));
      throw new InvalidOperationException("Invalid data column type.");
    }
    internal TOut TypeSwitch<TOut>(Func<DoublePreprocessingDataColumn, TOut> doubleFunc, Func<StringPreprocessingDataColumn, TOut> stringFunc = null, Func<DateTimePreprocessingDataColumn, TOut> dateTimeFunc = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleFunc != null) return doubleFunc(doubleColumn);
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringFunc != null) return stringFunc(stringColumn);
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeFunc != null) return dateTimeFunc(dateTimeColumn);
      throw new InvalidOperationException("Invalid data column type.");
    }
    internal TOut TypeSwitch<TIn, TOut>(TIn value, Func<DoublePreprocessingDataColumn, double, TOut> doubleFunc, Func<StringPreprocessingDataColumn, string, TOut> stringFunc = null, Func<DateTimePreprocessingDataColumn, DateTime, TOut> dateTimeFunc = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleFunc != null) return doubleFunc(doubleColumn, Convert<double>(value));
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringFunc != null) return stringFunc(stringColumn, Convert<string>(value));
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeFunc != null) return dateTimeFunc(dateTimeColumn, Convert<DateTime>(value));
      throw new InvalidOperationException("Invalid data column type.");
    }
    internal IEnumerable<TOut> TypeSwitch<TOut>(Func<DoublePreprocessingDataColumn, IEnumerable<double>> doubleFunc, Func<StringPreprocessingDataColumn, IEnumerable<string>> stringFunc = null, Func<DateTimePreprocessingDataColumn, IEnumerable<DateTime>> dateTimeFunc = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleFunc != null) return Convert<IEnumerable<TOut>>(doubleFunc(doubleColumn));
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringFunc != null) return Convert<IEnumerable<TOut>>(stringFunc(stringColumn));
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeFunc != null) return Convert<IEnumerable<TOut>>(dateTimeFunc(dateTimeColumn));
      throw new InvalidOperationException("Invalid data column type.");
    }
    internal IEnumerable<TOut> TypeSwitch<TOut, TIn>(TIn value, Func<DoublePreprocessingDataColumn, double, IEnumerable<double>> doubleFunc, Func<StringPreprocessingDataColumn, string, IEnumerable<string>> stringFunc = null, Func<DateTimePreprocessingDataColumn, DateTime, IEnumerable<DateTime>> dateTimeFunc = null) {
      var doubleColumn = this as DoublePreprocessingDataColumn;
      if (doubleColumn != null && doubleFunc != null) return Convert<IEnumerable<TOut>>(doubleFunc(doubleColumn, Convert<double>(value)));
      var stringColumn = this as StringPreprocessingDataColumn;
      if (stringColumn != null && stringFunc != null) return Convert<IEnumerable<TOut>>(stringFunc(stringColumn, Convert<string>(value)));
      var dateTimeColumn = this as DateTimePreprocessingDataColumn;
      if (dateTimeColumn != null && dateTimeFunc != null) return Convert<IEnumerable<TOut>>(dateTimeFunc(dateTimeColumn, Convert<DateTime>(value)));
      throw new InvalidOperationException("Invalid data column type.");
    }

    private static T Convert<T>(object obj) { return (T)obj; }
    #endregion

    #region Statistics
    public abstract int GetDistinctValues(IEnumerable<int> indices = null);
    public abstract int GetNumberOfMissingValues(IEnumerable<int> indices = null);
    #endregion

    #region String Handling
    public abstract bool Validate(string value, out string errorMessage);
    public abstract string GetValue(int index);
    public abstract bool SetValue(string value, int index);
    #endregion
  }

  [Item("PreprocessingDataColumn", "")]
  [StorableClass]
  public abstract class PreprocessingDataColumn<T> : PreprocessingDataColumn
    where T : IComparable<T> {

    #region Constructor, Cloning & Persistence
    protected PreprocessingDataColumn()
      : this(string.Empty, Enumerable.Empty<T>()) { }
    protected PreprocessingDataColumn(string name, IEnumerable<T> values)
      : base(name) {
      Values = new List<T>(values);
    }

    protected PreprocessingDataColumn(PreprocessingDataColumn<T> original, Cloner cloner)
      : base(original, cloner) {
      Values = new List<T>(original.Values);
    }

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

    [Storable]
    internal List<T> Values { get; private set; }
    public IEnumerable<T> GetValues(IEnumerable<int> indices = null) {
      return indices == null
        ? Values
        : indices.Select(index => Values[index]);
    }
    public IEnumerable<T> GetValidValues(IEnumerable<int> indices = null) {
      return indices == null
        ? Values.Where(IsValidValue)
        : indices.Select(index => Values[index]).Where(IsValidValue);
    }

    protected abstract T DefaultValue { get; }

    public override Type GetValueType() {
      return typeof(T);
    }

    public override int Length {
      get { return Values.Count; }
    }

    public T this[int index] {
      get { return Values[index]; }
      set { Values[index] = value; }
    }

    public virtual bool IsValidValue(T value) { return true; }
    public override bool IsValidValue(int index) {
      return IsValidValue(Values[index]);
    }

    #region Statistics

    public virtual T GetMin(IEnumerable<int> indices = null) { return GetValidValues(indices).DefaultIfEmpty(DefaultValue).Min(); }
    public virtual T GetMax(IEnumerable<int> indices = null) { return GetValidValues(indices).DefaultIfEmpty(DefaultValue).Max(); }
    public virtual T GetMedian(IEnumerable<int> indices = null) { return GetValidValues(indices).DefaultIfEmpty(DefaultValue).Quantile(0.5); }
    public virtual T GetMode(IEnumerable<int> indices = null) { return GetValidValues(indices).DefaultIfEmpty(DefaultValue).GroupBy(x => x).OrderByDescending(g => g.Count()).Select(g => g.Key).First(); }
    public virtual T GetQuantile(double alpha, IEnumerable<int> indices = null) { return GetValidValues(indices).DefaultIfEmpty(DefaultValue).Quantile(alpha); }
    public override int GetDistinctValues(IEnumerable<int> indices = null) { return GetValidValues(indices).GroupBy(x => x).Count(); }
    public override int GetNumberOfMissingValues(IEnumerable<int> indices = null) { return GetValues(indices).Count(x => !IsValidValue(x)); }
    #endregion
  }
}