Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
10/29/15 18:33:51 (8 years ago)
Author:
gkronber
Message:

#1998: merged changesets r10551:13081 (only on HeuristicLab.Problems.DataAnalysis) from trunk to branch

Location:
branches/ClassificationModelComparison/HeuristicLab.Problems.DataAnalysis
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/ClassificationModelComparison/HeuristicLab.Problems.DataAnalysis

  • branches/ClassificationModelComparison/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs

    r10553 r13083  
    11#region License Information
    22/* HeuristicLab
    3  * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
     3 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
    44 *
    55 * This file is part of HeuristicLab.
     
    3333  [Item("Dataset", "Represents a dataset containing data that should be analyzed.")]
    3434  [StorableClass]
    35   public sealed class Dataset : NamedItem, IStringConvertibleMatrix {
     35  public class Dataset : NamedItem, IDataset {
    3636    [StorableConstructor]
    37     private Dataset(bool deserializing) : base(deserializing) { }
    38     private Dataset(Dataset original, Cloner cloner)
     37    protected Dataset(bool deserializing) : base(deserializing) { }
     38    protected Dataset(Dataset original, Cloner cloner)
    3939      : base(original, cloner) {
    4040      variableValues = new Dictionary<string, IList>(original.variableValues);
     
    118118    }
    119119
     120    protected Dataset(Dataset dataset) : this(dataset.variableNames, dataset.variableValues.Values) { }
     121
    120122    #region Backwards compatible code, remove with 3.5
    121123    private double[,] storableData;
     
    143145
    144146    [Storable(Name = "VariableValues")]
    145     private Dictionary<string, IList> variableValues;
    146 
    147     private List<string> variableNames;
     147    protected Dictionary<string, IList> variableValues;
     148
     149    protected List<string> variableNames;
    148150    [Storable]
    149151    public IEnumerable<string> VariableNames {
    150152      get { return variableNames; }
    151       private set {
     153      protected set {
    152154        if (variableNames != null) throw new InvalidOperationException();
    153155        variableNames = new List<string>(value);
    154156      }
    155157    }
    156 
    157158    public IEnumerable<string> DoubleVariables {
    158159      get { return variableValues.Where(p => p.Value is List<double>).Select(p => p.Key); }
    159160    }
    160 
    161161    public IEnumerable<double> GetDoubleValues(string variableName) {
     162      return GetValues<double>(variableName);
     163    }
     164    public IEnumerable<string> GetStringValues(string variableName) {
     165      return GetValues<string>(variableName);
     166    }
     167    public IEnumerable<DateTime> GetDateTimeValues(string variableName) {
     168      return GetValues<DateTime>(variableName);
     169    }
     170
     171    public ReadOnlyCollection<double> GetReadOnlyDoubleValues(string variableName) {
     172      var values = GetValues<double>(variableName);
     173      return values.AsReadOnly();
     174    }
     175    public double GetDoubleValue(string variableName, int row) {
     176      var values = GetValues<double>(variableName);
     177      return values[row];
     178    }
     179    public IEnumerable<double> GetDoubleValues(string variableName, IEnumerable<int> rows) {
     180      return GetValues<double>(variableName, rows);
     181    }
     182    private IEnumerable<T> GetValues<T>(string variableName, IEnumerable<int> rows) {
     183      var values = GetValues<T>(variableName);
     184      return rows.Select(x => values[x]);
     185    }
     186    private List<T> GetValues<T>(string variableName) {
    162187      IList list;
    163188      if (!variableValues.TryGetValue(variableName, out list))
    164189        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
    165       List<double> values = list as List<double>;
    166       if (values == null) throw new ArgumentException("The variable " + variableName + " is not a double variable.");
    167 
    168       //mkommend yield return used to enable lazy evaluation
    169       foreach (double value in values)
    170         yield return value;
    171     }
    172     public ReadOnlyCollection<double> GetReadOnlyDoubleValues(string variableName) {
    173       IList list;
    174       if (!variableValues.TryGetValue(variableName, out list))
    175         throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
    176       List<double> values = list as List<double>;
    177       if (values == null) throw new ArgumentException("The variable " + variableName + " is not a double variable.");
    178       return values.AsReadOnly();
    179     }
    180     public double GetDoubleValue(string variableName, int row) {
    181       IList list;
    182       if (!variableValues.TryGetValue(variableName, out list))
    183         throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
    184       List<double> values = list as List<double>;
    185       if (values == null) throw new ArgumentException("The variable " + variableName + " is not a double variable.");
    186       return values[row];
    187     }
    188     public IEnumerable<double> GetDoubleValues(string variableName, IEnumerable<int> rows) {
    189       IList list;
    190       if (!variableValues.TryGetValue(variableName, out list))
    191         throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
    192       List<double> values = list as List<double>;
    193       if (values == null) throw new ArgumentException("The variable " + variableName + " is not a double variable.");
    194 
    195       return rows.Select(index => values[index]);
     190      List<T> values = list as List<T>;
     191      if (values == null) throw new ArgumentException("The variable " + variableName + " is not a " + typeof(T) + " variable.");
     192      return values;
     193    }
     194    public bool VariableHasType<T>(string variableName) {
     195      return variableValues[variableName] is IList<T>;
    196196    }
    197197
    198198    #region IStringConvertibleMatrix Members
    199199    [Storable]
    200     private int rows;
     200    protected int rows;
    201201    public int Rows {
    202202      get { return rows; }
     
    207207      set { throw new NotSupportedException(); }
    208208    }
    209 
    210209    public bool SortableView {
    211210      get { return false; }
     
    215214      get { return true; }
    216215    }
    217 
    218216    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
    219217      get { return this.VariableNames; }
     
    224222      set { throw new NotSupportedException(); }
    225223    }
    226 
    227224    public string GetValue(int rowIndex, int columnIndex) {
    228225      return variableValues[variableNames[columnIndex]][rowIndex].ToString();
    229226    }
    230     public bool SetValue(string value, int rowIndex, int columnIndex) {
     227    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
    231228      throw new NotSupportedException();
    232229    }
    233     public bool Validate(string value, out string errorMessage) {
     230    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
    234231      throw new NotSupportedException();
    235232    }
    236233
    237     public event EventHandler ColumnsChanged { add { } remove { } }
    238     public event EventHandler RowsChanged { add { } remove { } }
    239     public event EventHandler ColumnNamesChanged { add { } remove { } }
    240     public event EventHandler RowNamesChanged { add { } remove { } }
    241     public event EventHandler SortableViewChanged { add { } remove { } }
    242     public event EventHandler<EventArgs<int, int>> ItemChanged { add { } remove { } }
    243     public event EventHandler Reset { add { } remove { } }
     234    public virtual event EventHandler ColumnsChanged { add { } remove { } }
     235    public virtual event EventHandler RowsChanged { add { } remove { } }
     236    public virtual event EventHandler ColumnNamesChanged { add { } remove { } }
     237    public virtual event EventHandler RowNamesChanged { add { } remove { } }
     238    public virtual event EventHandler SortableViewChanged { add { } remove { } }
     239    public virtual event EventHandler<EventArgs<int, int>> ItemChanged { add { } remove { } }
     240    public virtual event EventHandler Reset { add { } remove { } }
    244241    #endregion
    245242  }
Note: See TracChangeset for help on using the changeset viewer.