Changeset 3933 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs

Timestamp:

06/21/10 13:21:14 (14 years ago)

Author:

mkommend

Message:

removed cloning of dataset and made it readonly (ticket #938)

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs (modified) (10 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs

@@ -35 +35 @@
   [StorableClass]
   public sealed class Dataset : NamedItem, IStringConvertibleMatrix {
-    public Dataset()
-      : base() {
-      this.Name = string.Empty;
-      this.data = new double[0, 0];
-      this.variableNames = new string[0];
-      this.SortableView = false;
+    [StorableConstructor]
+    protected Dataset(bool deserializing)
+      : base(deserializing) {
     }
 
     public Dataset(IEnumerable<string> variableNames, double[,] data)
-      : this() {
+      : base() {
       Name = "-";
       if (variableNames.Count() != data.GetLength(1)) {
         throw new ArgumentException("Number of variable names doesn't match the number of columns of data");
       }
-      this.data = data;
+      this.data = (double[,])data.Clone();
       this.variableNames = variableNames.ToArray();
     }
@@ -57 +54 @@
     public IEnumerable<string> VariableNames {
       get { return variableNames; }
-      private set {
-        if (variableNames != value) {
-          variableNames = value.ToArray();
-          OnColumnNamesChanged();
-        }
-      }
     }
 
@@ -69 +60 @@
     private double[,] Data {
       get { return data; }
-      set {
-        if (data != value) {
-          if (value == null) throw new ArgumentNullException();
-          this.data = value;
-          OnReset(EventArgs.Empty);
-        }
-      }
     }
 
@@ -81 +65 @@
     public double this[int rowIndex, int columnIndex] {
       get { return data[rowIndex, columnIndex]; }
-      set {
-        if (!value.Equals(data[rowIndex, columnIndex])) {
-          data[rowIndex, columnIndex] = value;
-          OnDataChanged(new EventArgs<int, int>(rowIndex, columnIndex));
-          OnItemChanged(rowIndex, columnIndex);
-        }
-      }
     }
+
     public double this[string variableName, int rowIndex] {
       get {
@@ -94 +72 @@
         return data[rowIndex, columnIndex];
       }
-      set {
-        int columnIndex = GetVariableIndex(variableName);
-        if (!value.Equals(data[rowIndex, columnIndex])) {
-          data[rowIndex, columnIndex] = value;
-          OnDataChanged(new EventArgs<int, int>(rowIndex, columnIndex));
-          OnItemChanged(rowIndex, columnIndex);
-        }
-      }
     }
-    // access to full columns
-    public double[] this[string variableName] {
-      get { return GetVariableValues(GetVariableIndex(variableName), 0, Rows); }
+
+    public double[] GetVariableValues(int variableIndex) {
+      return GetVariableValues(variableIndex, 0, Rows);
     }
 
@@ -118 +88 @@
         values[i] = data[i + start, variableIndex];
       return values;
+    }
+
+    public double[] GetVariableValues(string variableName) {
+      return GetVariableValues(GetVariableIndex(variableName), 0, Rows);
     }
 
@@ -135 +109 @@
       throw new ArgumentException("The variable name " + variableName + " was not found.");
     }
+    #endregion
 
-    public void SetVariableName(int variableIndex, string name) {
-      if (name == null) throw new ArgumentNullException("Cannot set variable name to null for variable at index " + variableIndex + " variableIndex");
-      if (variableNames.Contains(name)) throw new ArgumentException("The data set already contains a variable with name " + name + ".");
-      if (variableIndex < 0 || variableIndex >= variableNames.Length) throw new ArgumentException(" Cannot set name of not existent variable at index " + variableIndex + ".");
-      variableNames[variableIndex] = name;
-      OnColumnNamesChanged();
+    public double[,] GetClonedData() {
+      return (double[,])data.Clone();
     }
 
-    #endregion
-
-    #region variable statistics
-    public double GetMean(string variableName) {
-      return GetMean(GetVariableIndex(variableName));
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return this;
     }
 
-    public double GetMean(string variableName, int start, int end) {
-      return GetMean(GetVariableIndex(variableName), start, end);
-    }
-
-    public double GetMean(int variableIndex) {
-      return GetMean(variableIndex, 0, Rows);
-    }
-
-    public double GetMean(int variableIndex, int start, int end) {
-      return GetVariableValues(variableIndex, start, end).Average();
-    }
-
-    public double GetRange(string variableName) {
-      return GetRange(GetVariableIndex(variableName));
-    }
-
-    public double GetRange(int variableIndex) {
-      return GetRange(variableIndex, 0, Rows);
-    }
-
-    public double GetRange(string variableName, int start, int end) {
-      return GetRange(GetVariableIndex(variableName), start, end);
-    }
-
-    public double GetRange(int variableIndex, int start, int end) {
-      var values = GetVariableValues(variableIndex, start, end);
-      return values.Max() - values.Min();
-    }
-
-    public double GetMax(string variableName) {
-      return GetMax(GetVariableIndex(variableName));
-    }
-
-    public double GetMax(int variableIndex) {
-      return GetMax(variableIndex, 0, Rows);
-    }
-
-    public double GetMax(string variableName, int start, int end) {
-      return GetMax(GetVariableIndex(variableName), start, end);
-    }
-
-    public double GetMax(int variableIndex, int start, int end) {
-      return GetVariableValues(variableIndex, start, end).Max();
-    }
-
-    public double GetMin(string variableName) {
-      return GetMin(GetVariableIndex(variableName));
-    }
-
-    public double GetMin(int variableIndex) {
-      return GetMin(variableIndex, 0, Rows);
-    }
-
-    public double GetMin(string variableName, int start, int end) {
-      return GetMin(GetVariableIndex(variableName), start, end);
-    }
-
-    public double GetMin(int variableIndex, int start, int end) {
-      return GetVariableValues(variableIndex, start, end).Min();
-    }
-
-    public int GetMissingValues(string variableName) {
-      return GetMissingValues(GetVariableIndex(variableName));
-    }
-    public int GetMissingValues(int variableIndex) {
-      return GetMissingValues(variableIndex, 0, Rows);
-    }
-
-    public int GetMissingValues(string variableName, int start, int end) {
-      return GetMissingValues(GetVariableIndex(variableName), start, end);
-    }
-
-    public int GetMissingValues(int variableIndex, int start, int end) {
-      return GetVariableValues(variableIndex, start, end).Count(x => double.IsNaN(x));
-    }
-
-    #endregion
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Dataset clone = (Dataset)base.Clone(cloner);
-      clone.data = (double[,])data.Clone();
-      clone.variableNames = (string[])variableNames.Clone();
-      return clone;
-    }
-
-    #region events
-    public event EventHandler<EventArgs<int, int>> DataChanged;
-    private void OnDataChanged(EventArgs<int, int> e) {
-      var listeners = DataChanged;
-      if (listeners != null) listeners(this, e);
-    }
     public event EventHandler Reset;
     private void OnReset(EventArgs e) {
@@ -247 +124 @@
       if (listeners != null) listeners(this, e);
     }
-    #endregion
 
     #region IStringConvertibleMatrix Members
 
     public int Rows {
-      get {
-        return data.GetLength(0);
-      }
-      set {
-        if (value == 0) throw new ArgumentException("Number of rows must be at least one (for variable names)");
-        if (value != Rows) {
-          var newValues = new double[value, Columns];
-          for (int row = 0; row < Math.Min(Rows, value); row++) {
-            for (int column = 0; column < Columns; column++) {
-              newValues[row, column] = data[row, column];
-            }
-          }
-          Data = newValues;
-        }
-      }
+      get { return data.GetLength(0); }
+      set { throw new NotSupportedException(); }
     }
 
     public int Columns {
-      get {
-        return data.GetLength(1);
-      }
-      set {
-        if (value != Columns) {
-          var newValues = new double[Rows, value];
-          var newVariableNames = new string[value];
-          for (int row = 0; row < Rows; row++) {
-            for (int column = 0; column < Math.Min(value, Columns); column++) {
-              newValues[row, column] = data[row, column];
-            }
-          }
-          string formatString = new StringBuilder().Append('0', (int)Math.Log10(value) + 1).ToString(); // >= 100 variables => ###
-          for (int column = 0; column < value; column++) {
-            if (column < Columns)
-              newVariableNames[column] = variableNames[column];
-            else
-              newVariableNames[column] = "Var" + column.ToString(formatString);
-          }
-          VariableNames = newVariableNames;
-          Data = newValues;
-        }
-      }
+      get { return data.GetLength(1); }
+      set { throw new NotSupportedException(); }
     }
 
-    [Storable]
-    private bool sortableView;
     public bool SortableView {
-      get { return sortableView; }
-      set {
-        if (value != sortableView) {
-          sortableView = value;
-          OnSortableViewChanged();
-        }
-      }
+      get { return false; }
+      set { throw new NotSupportedException(); }
     }
 
     public bool ReadOnly {
-      get { return false; }
+      get { return true; }
     }
 
     IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
       get { return this.VariableNames; }
-      set {
-        int i = 0;
-        foreach (string variableName in value) {
-          SetVariableName(i, variableName);
-          i++;
-        }
-        OnColumnNamesChanged();
-      }
+      set { throw new NotSupportedException(); }
     }
 
     IEnumerable<string> IStringConvertibleMatrix.RowNames {
       get { return new List<string>(); }
-      set { throw new NotImplementedException(); }
+      set { throw new NotSupportedException(); }
     }
 
     public bool Validate(string value, out string errorMessage) {
-      double val;
-      bool valid = double.TryParse(value, out val);
-      errorMessage = string.Empty;
-      if (!valid) {
-        StringBuilder sb = new StringBuilder();
-        sb.Append("Invalid Value (Valid Value Format: \"");
-        sb.Append(FormatPatterns.GetDoubleFormatPattern());
-        sb.Append("\")");
-        errorMessage = sb.ToString();
-      }
-      return valid;
+      throw new NotSupportedException();
     }
 
@@ -347 +165 @@
 
     public bool SetValue(string value, int rowIndex, int columnIndex) {
-      double v;
-      if (double.TryParse(value, out v)) {
-        data[rowIndex, columnIndex] = v;
-        OnDataChanged(new EventArgs<int, int>(rowIndex, columnIndex));
-        OnItemChanged(rowIndex, columnIndex);
-        return true;
-      } else return false;
+      throw new NotSupportedException();
     }
 
@@ -381 +193 @@
     }
     #endregion
-
-
   }
 }