Changeset 16124 for stable/HeuristicLab.Problems.DataAnalysis

Timestamp:

09/06/18 12:19:23 (6 years ago)

Author:

mkommend

Message:

#2897: Merged r15769 and r15829 into stable.

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/ModifiableDataset.cs (modified) (5 diffs)

stable/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs

@@ -38 +38 @@
     protected Dataset(Dataset original, Cloner cloner)
       : base(original, cloner) {
+      // no need to clone the variable values because these can't be modified
       variableValues = new Dictionary<string, IList>(original.variableValues);
       variableNames = new List<string>(original.variableNames);
       rows = original.rows;
     }
+
     public override IDeepCloneable Clone(Cloner cloner) { return new Dataset(this, cloner); }
 
@@ -58 +60 @@
     /// <param name="variableValues">The values for the variables (column-oriented storage). Values are not cloned!</param>
     public Dataset(IEnumerable<string> variableNames, IEnumerable<IList> variableValues)
-      : base() {
+      : this(variableNames, variableValues, cloneValues: true) {
+    }
+
+    protected Dataset(IEnumerable<string> variableNames, IEnumerable<IList> variableValues, bool cloneValues = false) {
       Name = "-";
-      if (!variableNames.Any()) {
+
+      if (variableNames.Any()) {
+        this.variableNames = new List<string>(variableNames);
+      } else {
         this.variableNames = Enumerable.Range(0, variableValues.Count()).Select(x => "Column " + x).ToList();
-      } else if (variableNames.Count() != variableValues.Count()) {
-        throw new ArgumentException("Number of variable names doesn't match the number of columns of variableValues");
-      } else if (!variableValues.All(list => list.Count == variableValues.First().Count)) {
-        throw new ArgumentException("The number of values must be equal for every variable");
-      } else if (variableNames.Distinct().Count() != variableNames.Count()) {
-        var duplicateVariableNames =
-          variableNames.GroupBy(v => v).Where(g => g.Count() > 1).Select(g => g.Key).ToList();
-        string message = "The dataset cannot contain duplicate variables names: " + Environment.NewLine;
-        foreach (var duplicateVariableName in duplicateVariableNames)
-          message += duplicateVariableName + Environment.NewLine;
-        throw new ArgumentException(message);
-      }
+      }
+      // check if the arguments are consistent (no duplicate variables, same number of rows, correct data types, ...)
+      CheckArguments(this.variableNames, variableValues);
+
       rows = variableValues.First().Count;
-      this.variableNames = new List<string>(variableNames);
-      this.variableValues = new Dictionary<string, IList>(this.variableNames.Count);
-      for (int i = 0; i < this.variableNames.Count; i++) {
-        var values = variableValues.ElementAt(i);
-        this.variableValues.Add(this.variableNames[i], values);
+
+      if (cloneValues) {
+        this.variableValues = CloneValues(this.variableNames, variableValues);
+      } else {
+        this.variableValues = new Dictionary<string, IList>(this.variableNames.Count);
+        for (int i = 0; i < this.variableNames.Count; i++) {
+          var variableName = this.variableNames[i];
+          var values = variableValues.ElementAt(i);
+          this.variableValues.Add(variableName, values);
+        }
       }
     }
@@ -125 +130 @@
       return new ModifiableDataset(variableNames, values);
     }
+
     /// <summary>
     /// Shuffle a dataset's rows
@@ -231 +237 @@
       return new ReadOnlyCollection<DateTime>(values);
     }
-
-
     private IEnumerable<T> GetValues<T>(string variableName, IEnumerable<int> rows) {
       var values = GetValues<T>(variableName);
@@ -247 +251 @@
     public bool VariableHasType<T>(string variableName) {
       return variableValues[variableName] is IList<T>;
+    }
+    protected Type GetVariableType(string variableName) {
+      IList list;
+      variableValues.TryGetValue(variableName, out list);
+      if (list == null)
+        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
+      return GetElementType(list);
+    }
+    protected static Type GetElementType(IList list) {
+      var type = list.GetType();
+      return type.IsGenericType ? type.GetGenericArguments()[0] : type.GetElementType();
+    }
+    protected static bool IsAllowedType(IList list) {
+      var type = GetElementType(list);
+      return IsAllowedType(type);
+    }
+    protected static bool IsAllowedType(Type type) {
+      return type == typeof(double) || type == typeof(string) || type == typeof(DateTime);
+    }
+
+    protected static void CheckArguments(IEnumerable<string> variableNames, IEnumerable<IList> variableValues) {
+      if (variableNames.Count() != variableValues.Count()) {
+        throw new ArgumentException("Number of variable names doesn't match the number of columns of variableValues");
+      } else if (!variableValues.All(list => list.Count == variableValues.First().Count)) {
+        throw new ArgumentException("The number of values must be equal for every variable");
+      } else if (variableNames.Distinct().Count() != variableNames.Count()) {
+        var duplicateVariableNames =
+          variableNames.GroupBy(v => v).Where(g => g.Count() > 1).Select(g => g.Key).ToList();
+        string message = "The dataset cannot contain duplicate variables names: " + Environment.NewLine;
+        foreach (var duplicateVariableName in duplicateVariableNames)
+          message += duplicateVariableName + Environment.NewLine;
+        throw new ArgumentException(message);
+      }
+      // check if all the variables are supported
+      foreach (var t in variableNames.Zip(variableValues, Tuple.Create)) {
+        var variableName = t.Item1;
+        var values = t.Item2;
+
+        if (!IsAllowedType(values)) {
+          throw new ArgumentException(string.Format("Unsupported type {0} for variable {1}.", GetElementType(values), variableName));
+        }
+      }
+    }
+
+    protected static Dictionary<string, IList> CloneValues(Dictionary<string, IList> variableValues) {
+      return variableValues.ToDictionary(x => x.Key, x => CloneValues(x.Value));
+    }
+
+    protected static Dictionary<string, IList> CloneValues(IEnumerable<string> variableNames, IEnumerable<IList> variableValues) {
+      return variableNames.Zip(variableValues, Tuple.Create).ToDictionary(x => x.Item1, x => CloneValues(x.Item2));
+    }
+
+    protected static IList CloneValues(IList values) {
+      var doubleValues = values as IList<double>;
+      if (doubleValues != null) return new List<double>(doubleValues);
+
+      var stringValues = values as IList<string>;
+      if (stringValues != null) return new List<string>(stringValues);
+
+      var dateTimeValues = values as IList<DateTime>;
+      if (dateTimeValues != null) return new List<DateTime>(dateTimeValues);
+
+      throw new ArgumentException(string.Format("Unsupported variable type {0}.", GetElementType(values)));
     }
 

stable/HeuristicLab.Problems.DataAnalysis/3.4/ModifiableDataset.cs

@@ -39 +39 @@
 
     private ModifiableDataset(ModifiableDataset original, Cloner cloner) : base(original, cloner) {
-      var variables = variableValues.Keys.ToList();
-      foreach (var v in variables) {
-        var type = GetVariableType(v);
-        if (type == typeof(DateTime)) {
-          variableValues[v] = GetDateTimeValues(v).ToList();
-        } else if (type == typeof(double)) {
-          variableValues[v] = GetDoubleValues(v).ToList();
-        } else if (type == typeof(string)) {
-          variableValues[v] = GetStringValues(v).ToList();
-        } else {
-          throw new ArgumentException("Unsupported type " + type + " for variable " + v);
-        }
-      }
-    }
+      variableNames = new List<string>(original.variableNames);
+      variableValues = CloneValues(original.variableValues);
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) { return new ModifiableDataset(this, cloner); }
-    public ModifiableDataset() : base() { }
-
-    public ModifiableDataset(IEnumerable<string> variableNames, IEnumerable<IList> variableValues) : base(variableNames, variableValues) { }
+
+    public ModifiableDataset() { }
+
+    public ModifiableDataset(IEnumerable<string> variableNames, IEnumerable<IList> variableValues) :
+      base(variableNames, variableValues, cloneValues: false) { }
 
     public void ReplaceRow(int row, IEnumerable<object> values) {
@@ -105 +97 @@
 
     // adds a new variable to the dataset
-    public void AddVariable<T>(string variableName, IEnumerable<T> values) {
+    public void AddVariable(string variableName, IList values) {
       if (variableValues.ContainsKey(variableName))
-        throw new ArgumentException("Variable " + variableName + " is already present in the dataset.");
-      int count = values.Count();
-      if (count != rows)
-        throw new ArgumentException("The number of values must exactly match the number of rows in the dataset.");
-      variableValues[variableName] = new List<T>(values);
+        throw new ArgumentException(string.Format("Variable {0} is already present in the dataset.", variableName));
+
+      if (values == null || values.Count == 0)
+        throw new ArgumentException("Cannot add variable with no values.");
+
+      if (!IsAllowedType(values))
+        throw new ArgumentException(string.Format("Unsupported type {0} for variable {1}.", GetElementType(values), variableName));
+
+      variableValues[variableName] = values;
       variableNames.Add(variableName);
+
       OnColumnsChanged();
       OnColumnNamesChanged();
@@ -120 +117 @@
     public void RemoveVariable(string variableName) {
       if (!variableValues.ContainsKey(variableName))
-        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
+        throw new ArgumentException(string.Format("The variable {0} does not exist in the dataset.", variableName));
       variableValues.Remove(variableName);
       variableNames.Remove(variableName);
@@ -128 +125 @@
     }
 
-    // slow, avoid to use this
+    // slow, avoid using this
     public void RemoveRow(int row) {
       foreach (var list in variableValues.Values)
@@ -151 +148 @@
     }
 
-    private Type GetVariableType(string variableName) {
-      IList list;
-      variableValues.TryGetValue(variableName, out list);
-      if (list == null)
-        throw new ArgumentException("The variable " + variableName + " does not exist in the dataset.");
-      return list.GetType().GetGenericArguments()[0];
-    }
-
     bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
       var variableName = variableNames[columnIndex];