Changeset 3308


Ignore:
Timestamp:
04/12/10 14:14:39 (11 years ago)
Author:
mkommend
Message:

added ColumnNames property in IStringConvertibleMatrix and in classes implementing this interface (ticket #968)

Location:
trunk/sources
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Data/3.3/BoolMatrix.cs

    r3160 r3308  
    2020#endregion
    2121
     22using System.Collections.Generic;
    2223using System.Text;
    2324using HeuristicLab.Core;
     
    7374      set { Columns = value; }
    7475    }
     76    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
     77      get { return this.ColumnNames; }
     78      set { this.ColumnNames = value; }
     79    }
    7580    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
    7681      return Validate(value, out errorMessage);
  • trunk/sources/HeuristicLab.Data/3.3/DoubleMatrix.cs

    r3160 r3308  
    2020#endregion
    2121
     22using System.Collections.Generic;
    2223using System.Text;
    2324using HeuristicLab.Core;
     
    7374      set { Columns = value; }
    7475    }
     76    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
     77      get { return this.ColumnNames; }
     78      set { this.ColumnNames = value; }
     79    }
    7580    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
    7681      return Validate(value, out errorMessage);
  • trunk/sources/HeuristicLab.Data/3.3/IStringConvertibleMatrix.cs

    r3048 r3308  
    2222using System;
    2323using HeuristicLab.Common;
     24using System.Collections.Generic;
    2425
    2526namespace HeuristicLab.Data {
     
    2728    int Rows { get; set; }
    2829    int Columns { get; set; }
     30
     31    IEnumerable<string> ColumnNames { get; set; }
     32    //bool SortableView { get; }
    2933
    3034    bool Validate(string value, out string errorMessage);
  • trunk/sources/HeuristicLab.Data/3.3/IntMatrix.cs

    r3160 r3308  
    2020#endregion
    2121
     22using System.Collections.Generic;
    2223using System.Text;
    2324using HeuristicLab.Core;
     
    7374      set { Columns = value; }
    7475    }
     76    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
     77      get { return this.ColumnNames; }
     78      set { this.ColumnNames = value; }
     79    }
    7580    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
    7681      return Validate(value, out errorMessage);
  • trunk/sources/HeuristicLab.Data/3.3/StringMatrix.cs

    r3306 r3308  
    2222using System;
    2323using System.Collections;
     24using System.Collections.Generic;
    2425using System.Drawing;
     26using System.Linq;
    2527using System.Text;
    2628using HeuristicLab.Common;
     
    3840    [Storable]
    3941    protected string[,] matrix;
     42
     43    [Storable]
     44    protected List<string> columnNames;
     45    public IEnumerable<string> ColumnNames {
     46      get { return this.columnNames; }
     47      set {
     48        if (value == null || value.Count() == 0)
     49          columnNames = new List<string>();
     50        else if (value.Count() != Columns)
     51          throw new ArgumentException("A columnName must be for each column specified.");
     52        else
     53          columnNames = new List<string>(value);
     54      }
     55    }
    4056
    4157    public virtual int Rows {
     
    7692    public StringMatrix() {
    7793      matrix = new string[0, 0];
     94      columnNames = new List<string>();
    7895    }
    7996    public StringMatrix(int rows, int columns) {
     
    83100          matrix[i, j] = string.Empty;
    84101      }
     102      columnNames = new List<string>();
     103    }
     104    protected StringMatrix(int rows, int columns, IEnumerable<string> columnNames)
     105      : this(rows, columns) {
     106      ColumnNames = columnNames;
    85107    }
    86108    public StringMatrix(string[,] elements) {
     
    91113          matrix[i, j] = elements[i, j] == null ? string.Empty : elements[i, j];
    92114      }
     115      columnNames = new List<string>();
     116    }
     117    protected StringMatrix(string[,] elements, IEnumerable<string> columnNames)
     118      : this(elements) {
     119      ColumnNames = columnNames;
    93120    }
    94121
     
    162189      set { Columns = value; }
    163190    }
     191    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
     192      get { return this.ColumnNames; }
     193      set { this.ColumnNames = value; }
     194    }
    164195    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
    165196      return Validate(value, out errorMessage);
  • trunk/sources/HeuristicLab.Data/3.3/ValueTypeMatrix.cs

    r3306 r3308  
    2222using System;
    2323using System.Collections;
     24using System.Collections.Generic;
    2425using System.Drawing;
     26using System.Linq;
    2527using System.Text;
    2628using HeuristicLab.Common;
     
    3840    [Storable]
    3941    protected T[,] matrix;
     42
     43    [Storable]
     44    protected List<string> columnNames;
     45    public IEnumerable<string> ColumnNames {
     46      get { return this.columnNames; }
     47      set {
     48        if (value == null || value.Count() == 0)
     49          columnNames = new List<string>();
     50        else if (value.Count() != Columns)
     51          throw new ArgumentException("A columnName must be for each column specified.");
     52        else
     53          columnNames = new List<string>(value);
     54      }
     55    }
    4056
    4157    public virtual int Rows {
     
    7490    protected ValueTypeMatrix() {
    7591      matrix = new T[0, 0];
     92      columnNames = new List<string>();
    7693    }
    7794    protected ValueTypeMatrix(int rows, int columns) {
    7895      matrix = new T[rows, columns];
     96      columnNames = new List<string>();
     97    }
     98    protected ValueTypeMatrix(int rows, int columns, IEnumerable<string> columnNames)
     99      : this(rows, columns) {
     100      ColumnNames = columnNames;
    79101    }
    80102    protected ValueTypeMatrix(T[,] elements) {
    81103      if (elements == null) throw new ArgumentNullException();
    82104      matrix = (T[,])elements.Clone();
     105      columnNames = new List<string>();
     106    }
     107    protected ValueTypeMatrix(T[,] elements, IEnumerable<string> columnNames)
     108      : this(elements) {
     109      ColumnNames = columnNames;
    83110    }
    84111
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Dataset.cs

    r3294 r3308  
    4545        throw new ArgumentException("Number of variable names doesn't match the number of columns of data");
    4646      }
    47       Data = new DoubleMatrix(data);
    48       this.variableNames = new StringArray(variableNames.ToArray());
     47      Data = data;
     48      this.variableNames = variableNames.ToArray();
    4949    }
    5050
    5151    [Storable]
    52     private StringArray variableNames;
     52    private string[] variableNames;
    5353    public IEnumerable<string> VariableNames {
    5454      get { return variableNames; }
     
    5656
    5757    [Storable]
    58     private DoubleMatrix data;
    59     private DoubleMatrix Data {
     58    private double[,] data;
     59    private double[,] Data {
    6060      get { return data; }
    6161      set {
    6262        if (data != value) {
    6363          if (value == null) throw new ArgumentNullException();
    64           if (data != null) DeregisterDataEvents();
    6564          this.data = value;
    66           RegisterDataEvents();
    6765          OnReset(EventArgs.Empty);
    6866        }
     
    7068    }
    7169
    72     private void RegisterDataEvents() {
    73       data.Reset += new EventHandler(data_Reset);
    74       data.ItemChanged += new EventHandler<EventArgs<int, int>>(data_ItemChanged);
    75     }
    76 
    77     private void DeregisterDataEvents() {
    78       data.Reset -= new EventHandler(data_Reset);
    79       data.ItemChanged -= new EventHandler<EventArgs<int, int>>(data_ItemChanged);
    80     }
    8170    // elementwise access
    8271    public double this[int rowIndex, int columnIndex] {
     
    9180    // access to full columns
    9281    public double[] this[string variableName] {
    93       get { return GetVariableValues(GetVariableIndex(variableName), 0, data.Rows); }
     82      get { return GetVariableValues(GetVariableIndex(variableName), 0, Rows); }
    9483    }
    9584
     
    9786      if (start < 0 || !(start <= end))
    9887        throw new ArgumentException("Start must be between 0 and end (" + end + ").");
    99       if (end > data.Rows || end < start)
    100         throw new ArgumentException("End must be between start (" + start + ") and dataset rows (" + data.Rows + ").");
     88      if (end > Rows || end < start)
     89        throw new ArgumentException("End must be between start (" + start + ") and dataset rows (" + Rows + ").");
    10190
    10291      double[] values = new double[end - start];
     
    123112
    124113    public void SetVariableName(int variableIndex, string name) {
     114      if (name == null) throw new ArgumentNullException("Cannot set variable name to null for variable at index " + variableIndex + " variableIndex");
    125115      if (variableNames.Contains(name)) throw new ArgumentException("The data set already contains a variable with name " + name + ".");
     116      if (variableIndex < 0 || variableIndex >= variableNames.Length) throw new ArgumentException(" Cannot set name of not existent variable at index " + variableIndex + ".");
    126117      variableNames[variableIndex] = name;
    127118    }
     
    139130
    140131    public double GetMean(int variableIndex) {
    141       return GetMean(variableIndex, 0, data.Rows);
     132      return GetMean(variableIndex, 0, Rows);
    142133    }
    143134
     
    151142
    152143    public double GetRange(int variableIndex) {
    153       return GetRange(variableIndex, 0, data.Rows);
     144      return GetRange(variableIndex, 0, Rows);
    154145    }
    155146
     
    168159
    169160    public double GetMax(int variableIndex) {
    170       return GetMax(variableIndex, 0, data.Rows);
     161      return GetMax(variableIndex, 0, Rows);
    171162    }
    172163
     
    184175
    185176    public double GetMin(int variableIndex) {
    186       return GetMin(variableIndex, 0, data.Rows);
     177      return GetMin(variableIndex, 0, Rows);
    187178    }
    188179
     
    199190    }
    200191    public int GetMissingValues(int variableIndex) {
    201       return GetMissingValues(variableIndex, 0, data.Rows);
     192      return GetMissingValues(variableIndex, 0, Rows);
    202193    }
    203194
     
    214205    public override IDeepCloneable Clone(Cloner cloner) {
    215206      Dataset clone = (Dataset)base.Clone(cloner);
    216       clone.data = (DoubleMatrix)data.Clone(cloner);
    217       clone.variableNames = (StringArray)variableNames.Clone(cloner);
     207      clone.data = (double[,])data.Clone();
     208      clone.variableNames = (string[])variableNames.Clone();
    218209      return clone;
    219210    }
     
    244235    public int Rows {
    245236      get {
    246         return data.Rows + 1;
     237        return data.GetLength(0);
    247238      }
    248239      set {
    249240        if (value == 0) throw new ArgumentException("Number of rows must be at least one (for variable names)");
    250         if (value - 1 != data.Rows) {
    251           var newValues = new double[value - 1, data.Columns];
    252           for (int row = 0; row < Math.Min(data.Rows, value - 1); row++) {
    253             for (int column = 0; column < data.Columns; column++) {
     241        if (value != Rows) {
     242          var newValues = new double[value, Columns];
     243          for (int row = 0; row < Math.Min(Rows, value); row++) {
     244            for (int column = 0; column < Columns; column++) {
    254245              newValues[row, column] = data[row, column];
    255246            }
    256247          }
    257           Data = new DoubleMatrix(newValues);
     248          Data = newValues;
    258249        }
    259250      }
     
    262253    public int Columns {
    263254      get {
    264         return data.Columns;
    265       }
    266       set {
    267         if (value != data.Columns) {
    268           var newValues = new double[data.Rows, value];
     255        return data.GetLength(1);
     256      }
     257      set {
     258        if (value != Columns) {
     259          var newValues = new double[Rows, value];
    269260          var newVariableNames = new string[value];
    270           for (int row = 0; row < data.Rows; row++) {
    271             for (int column = 0; column < Math.Min(value, data.Columns); column++) {
     261          for (int row = 0; row < Rows; row++) {
     262            for (int column = 0; column < Math.Min(value, Columns); column++) {
    272263              newValues[row, column] = data[row, column];
    273264            }
     
    275266          string formatString = new StringBuilder().Append('0', (int)Math.Log10(value) + 1).ToString(); // >= 100 variables => ###
    276267          for (int column = 0; column < value; column++) {
    277             if (column < data.Columns)
     268            if (column < Columns)
    278269              newVariableNames[column] = variableNames[column];
    279270            else
    280271              newVariableNames[column] = "Var" + column.ToString(formatString);
    281272          }
    282           variableNames = new StringArray(newVariableNames);
    283           Data = new DoubleMatrix(newValues);
     273          variableNames = newVariableNames;
     274          Data = newValues;
     275        }
     276      }
     277    }
     278
     279    IEnumerable<string> IStringConvertibleMatrix.ColumnNames {
     280      get { return this.VariableNames; }
     281      set {
     282        int i = 0;
     283        foreach (string variableName in value) {
     284          SetVariableName(i, variableName);
     285          i++;
    284286        }
    285287      }
     
    292294
    293295    public string GetValue(int rowIndex, int columnIndex) {
    294       if (rowIndex == 0) {
    295         // return variable name
    296         return variableNames[columnIndex];
    297       } else {
    298         return data[rowIndex - 1, columnIndex].ToString();
    299       }
     296      return data[rowIndex, columnIndex].ToString();
    300297    }
    301298
    302299    public bool SetValue(string value, int rowIndex, int columnIndex) {
    303       if (rowIndex == 0) {
    304         // check if the variable name is already used
    305         if (variableNames.Contains(value)) {
    306           return false;
    307         } else {
    308           variableNames[columnIndex] = value;
    309           return true;
    310         }
    311       } else {
    312         double v;
    313         if (double.TryParse(value, out v)) {
    314           data[rowIndex - 1, columnIndex] = v;
    315           return true;
    316         } else return false;
    317       }
     300      double v;
     301      if (double.TryParse(value, out v)) {
     302        data[rowIndex, columnIndex] = v;
     303        return true;
     304      } else return false;
    318305    }
    319306
    320307    public event EventHandler<EventArgs<int, int>> ItemChanged;
    321 
    322308    #endregion
    323309  }
Note: See TracChangeset for help on using the changeset viewer.