Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2839_HiveProjectManagement/HeuristicLab.Problems.DataAnalysis/3.4/ModifiableDataset.cs @ 16092

Last change on this file since 16092 was 16092, checked in by jkarder, 6 years ago

#2839: merged [16057-16091/trunk] into branch

File size: 8.7 KB
RevLine 
[11589]1#region License Information
2
3/* HeuristicLab
[16057]4 * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[11589]5 *
6 * This file is part of HeuristicLab.
7 *
8 * HeuristicLab is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * HeuristicLab is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#endregion
23
24using System;
25using System.Collections;
26using System.Collections.Generic;
27using System.Linq;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
[12141]30using HeuristicLab.Data;
[11589]31using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
32
33namespace HeuristicLab.Problems.DataAnalysis {
34  [Item("ModifiableDataset", "Represents a dataset containing data that should be analyzed, which can be modified by adding or replacing variables and values.")]
35  [StorableClass]
[12511]36  public sealed class ModifiableDataset : Dataset, IStringConvertibleMatrix {
[11589]37    [StorableConstructor]
38    private ModifiableDataset(bool deserializing) : base(deserializing) { }
[13027]39
40    private ModifiableDataset(ModifiableDataset original, Cloner cloner) : base(original, cloner) {
[16057]41      variableNames = new List<string>(original.variableNames);
42      variableValues = CloneValues(original.variableValues);
[13027]43    }
[16057]44
[11589]45    public override IDeepCloneable Clone(Cloner cloner) { return new ModifiableDataset(this, cloner); }
[12508]46
[16057]47    public ModifiableDataset() { }
[11589]48
[16092]49    public ModifiableDataset(IEnumerable<string> variableNames, IEnumerable<IList> variableValues, bool cloneValues = false) :
50      base(variableNames, variableValues, cloneValues) { }
[16057]51
[16092]52    public Dataset ToDataset() {
53      return new Dataset(variableNames, variableNames.Select(v => variableValues[v]));
54    }
[11589]55    public void ReplaceRow(int row, IEnumerable<object> values) {
56      var list = values.ToList();
57      if (list.Count != variableNames.Count)
58        throw new ArgumentException("The number of values must be equal to the number of variable names.");
59      // check if all the values are of the correct type
60      for (int i = 0; i < list.Count; ++i) {
61        if (list[i].GetType() != GetVariableType(variableNames[i])) {
62          throw new ArgumentException("The type of the provided value does not match the variable type.");
63        }
64      }
65      // replace values
66      for (int i = 0; i < list.Count; ++i) {
67        variableValues[variableNames[i]][row] = list[i];
68      }
[12489]69      OnReset();
[11589]70    }
71
[13761]72    public void ReplaceVariable(string variableName, IList values) {
[13760]73      if (!variableValues.ContainsKey(variableName))
[14826]74        throw new ArgumentException(string.Format("Variable {0} is not present in the dataset.", variableName));
[13760]75      if (values.Count != variableValues[variableName].Count)
76        throw new ArgumentException("The number of values must coincide with the number of dataset rows.");
77      if (GetVariableType(variableName) != values[0].GetType())
78        throw new ArgumentException("The type of the provided value does not match the variable type.");
79      variableValues[variableName] = values;
80    }
81
[11589]82    public void AddRow(IEnumerable<object> values) {
83      var list = values.ToList();
84      if (list.Count != variableNames.Count)
85        throw new ArgumentException("The number of values must be equal to the number of variable names.");
86      // check if all the values are of the correct type
87      for (int i = 0; i < list.Count; ++i) {
88        if (list[i].GetType() != GetVariableType(variableNames[i])) {
89          throw new ArgumentException("The type of the provided value does not match the variable type.");
90        }
91      }
92      // add values
93      for (int i = 0; i < list.Count; ++i) {
94        variableValues[variableNames[i]].Add(list[i]);
95      }
[16092]96      Rows++;
[12489]97      OnRowsChanged();
98      OnReset();
[11589]99    }
100
[12032]101    // adds a new variable to the dataset
[16057]102    public void AddVariable(string variableName, IList values) {
[16092]103      InsertVariable(variableName, Columns, values);
104    }
105
106
107    public void InsertVariable(string variableName, int position, IList values) {
[12032]108      if (variableValues.ContainsKey(variableName))
[16057]109        throw new ArgumentException(string.Format("Variable {0} is already present in the dataset.", variableName));
110
[16092]111      if (position < 0 || position > Columns)
112        throw new ArgumentException(string.Format("Incorrect position {0} specified. The position must be between 0 and {1}.", position, Columns));
[16057]113
[16092]114      if (values == null)
115        throw new ArgumentNullException("values", "Values must not be null. At least an empty list of values has to be provided.");
116
117      if (values.Count != Rows)
118        throw new ArgumentException(string.Format("{0} values are provided, but {1} rows are present in the dataset.", values.Count, Rows));
119
[16057]120      if (!IsAllowedType(values))
121        throw new ArgumentException(string.Format("Unsupported type {0} for variable {1}.", GetElementType(values), variableName));
122
[16092]123      variableNames.Insert(position, variableName);
[16057]124      variableValues[variableName] = values;
125
[12489]126      OnColumnsChanged();
127      OnColumnNamesChanged();
128      OnReset();
[12032]129    }
130
131    public void RemoveVariable(string variableName) {
132      if (!variableValues.ContainsKey(variableName))
[16057]133        throw new ArgumentException(string.Format("The variable {0} does not exist in the dataset.", variableName));
[12032]134      variableValues.Remove(variableName);
135      variableNames.Remove(variableName);
[12489]136      OnColumnsChanged();
137      OnColumnNamesChanged();
138      OnReset();
[12032]139    }
140
[16057]141    // slow, avoid using this
[11589]142    public void RemoveRow(int row) {
143      foreach (var list in variableValues.Values)
144        list.RemoveAt(row);
[16092]145      Rows--;
[12489]146      OnRowsChanged();
147      OnReset();
[11589]148    }
149
[12141]150    public void SetVariableValue(object value, string variableName, int row) {
[12032]151      IList list;
152      variableValues.TryGetValue(variableName, out list);
153      if (list == null)
154        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
155      if (row < 0 || list.Count < row)
156        throw new ArgumentOutOfRangeException("Invalid row value");
[12141]157      if (GetVariableType(variableName) != value.GetType())
158        throw new ArgumentException("The type of the provided value does not match the variable type.");
159
[12032]160      list[row] = value;
[12508]161      OnItemChanged(row, variableNames.IndexOf(variableName));
[12032]162    }
163
[12141]164    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
165      var variableName = variableNames[columnIndex];
166      // if value represents a double
167      double dv;
168      if (double.TryParse(value, out dv)) {
169        SetVariableValue(dv, variableName, rowIndex);
170        return true;
171      }
172      // if value represents a DateTime object
173      DateTime dt;
174      if (DateTime.TryParse(value, out dt)) {
175        SetVariableValue(dt, variableName, rowIndex);
176        return true;
177      }
178      // if value is simply a string
179      SetVariableValue(value, variableName, rowIndex);
180      return true;
181    }
182
183    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
[12508]184      errorMessage = string.Empty;
185      return true;
[12141]186    }
187
[12489]188    #region event handlers
189    public override event EventHandler RowsChanged;
190    private void OnRowsChanged() {
[12508]191      var handler = RowsChanged;
192      if (handler != null)
193        handler(this, EventArgs.Empty);
[12489]194    }
195
196    public override event EventHandler ColumnsChanged;
197    private void OnColumnsChanged() {
[12508]198      var handler = ColumnsChanged;
199      if (handler != null)
200        handler(this, EventArgs.Empty);
[12489]201    }
202
203    public override event EventHandler ColumnNamesChanged;
204    private void OnColumnNamesChanged() {
[12508]205      var handler = ColumnNamesChanged;
206      if (handler != null)
207        handler(this, EventArgs.Empty);
[12489]208    }
209
210    public override event EventHandler Reset;
211    private void OnReset() {
[12508]212      var handler = Reset;
213      if (handler != null)
214        handler(this, EventArgs.Empty);
[12489]215    }
216
217    public override event EventHandler<EventArgs<int, int>> ItemChanged;
218    private void OnItemChanged(int rowIndex, int columnIndex) {
[12508]219      var handler = ItemChanged;
220      if (handler != null) {
221        handler(this, new EventArgs<int, int>(rowIndex, columnIndex));
[12489]222      }
223    }
224    #endregion
[11589]225  }
226}
Note: See TracBrowser for help on using the repository browser.