source: branches/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/ProblemDescription/DistanceMatrix.cs @ 13071

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.Linq;

namespace HeuristicLab.BioBoost.ProblemDescription {

  [Item("DistanceMatrix", "Represents a space-efficient, symmetric distance matrix of double values.")]
  [StorableClass]
  public class DistanceMatrix : NamedItem, IStringConvertibleMatrix {

    public new static Image StaticItemImage {
      get { return Common.Resources.VSImageLibrary.Class; }
    }

    [Storable]
    public int Size { get; private set; }

    [Storable]
    public double Max { get; private set; }

    [Storable]
    public double Min { get; private set; }

    [Storable]
    private IEnumerable<double> Values_Persistence {
      get { return values; }
      set { values = new List<double>(value);}
    }

    private List<double> values;

    #region Construction & Cloning
    [StorableConstructor]
    protected DistanceMatrix(bool isDeserializing) : base(isDeserializing) { }
    protected DistanceMatrix(DistanceMatrix original, Cloner cloner)
      : base(original, cloner) {
      values = original.values.ToList();
      Size = original.Size;
      Min = original.Min;
      Max = original.Max;
      Name = original.Name;
    }
    public DistanceMatrix() {
      values = new List<double>();
      Size = 0;
      Min = Double.NaN;
      Max = Double.NaN;
      Name = this.ItemName;
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new DistanceMatrix(this, cloner);
    }
    #endregion

    protected virtual bool Validate(string value, out string errorMessage) {
      double val;
      if (!double.TryParse(value, out val)) {
        errorMessage = string.Format(
          "Invalid Value (Valid Value Format: '{0}')",
          FormatPatterns.GetDoubleFormatPattern());
        return false;
      } else {
        errorMessage = string.Empty;
        return true;
      }
    }

    protected int GetLinearIndex(int row, int col) {
      if (row >= col)
        return row*(row + 1)/2 + col;
      else
        return col*(col + 1)/2 + row;
    }

    public double this[int row, int col] {
      get {
        var value = values[GetLinearIndex(row, col)];
        return value >= 0 ? value :
          row == col ? Max*2 : Max*4;
      }
      set {
        var i = GetLinearIndex(row, col);
        var oldValue = values[i];
        values[GetLinearIndex(row, col)] = value;
        CheckBounds(oldValue, value);
        OnItemChanged(row, col);
        OnToStringChanged();
      }
    }

    protected void CheckBounds(double oldValue, double value) {
      if (Double.IsNaN(Max) || value > Max) {
        Max = value;
      } else if (oldValue == Max) {
        Max = values.Max();
      }
      if (Double.IsNaN(Min) || value < Min) {
        Min = value;
      } else if (oldValue == Min) {
        Min = values.Min();
      }
    }

    protected virtual string GetValue(int rowIndex, int columIndex) {
      return this[rowIndex, columIndex].ToString(CultureInfo.InvariantCulture);
    }

    protected virtual bool SetValue(string value, int rowIndex, int columnIndex) {
      double val;
      if (double.TryParse(value, out val)) {
        this[rowIndex, columnIndex] = val;
        return true;
      } else {
        return false;
      }
    }

    public void Load(IEnumerable<Tuple<string, string, double>> labeledValues, IEnumerable<string> finalOrder, double defaultValue) {
      var dict = labeledValues.ToDictionary(t => new {x = t.Item1, y = t.Item2}, t => t.Item3);
      var labels = finalOrder.ToList();
      Size = labels.Count;
      values.Clear();
      for (int i = 0; i<Size; i++) {
        for (int j = 0; j<=i; j++) {
          double value;
          if (dict.TryGetValue(new { x = labels[i], y = labels[j] }, out value)) {
            values.Add(value);
          } else if (dict.TryGetValue(new { x = labels[j], y = labels[i] }, out value)) {
            values.Add(value);
          } else {
            values.Add(defaultValue);
          }
        }
      }
      Min = values.Min();
      Max = values.Max();
      OnRowNamesChanged();
      OnColumnNamesChanged();
      OnRowsChanged();
      OnColumnsChanged();
      OnReset();
    }

    public DistanceMatrix CopyAndRemoveIndices(IEnumerable<int> indices) {
      var idx = new HashSet<int>(indices);
      int ii = 0, jj = 0;
      var dm = new DistanceMatrix {Size = Size - idx.Count};
      for (int i = 0; i < Size; i++) {
        if (!idx.Contains(i)) {
          for (int j = 0; j <= i; j++) {
            if (!idx.Contains(j)) {
              //dm[ii, jj] = this[i, j];
              dm.values.Add(this[i, j]);
            }
            jj++;
          }
        }
        ii++;
      }
      dm.Min = dm.values.Count > 0 ? dm.values.Min() : 0;
      dm.Max = dm.values.Count > 0 ? dm.values.Max() : 0;
      OnRowNamesChanged();
      OnColumnNamesChanged();
      OnRowsChanged();
      OnColumnsChanged();
      OnReset();
      return dm;
    }

    #region IStringConvertibleMatrix Members

    public int Rows { get { return Size; } set { throw new NotImplementedException(); } }
    public int Columns { get { return Size; } set { throw new NotImplementedException(); } }
    public bool ReadOnly { get { return true; } }

    public IEnumerable<string> RowNames {
      get { return Enumerable.Range(0, Size).Select(i => i.ToString(CultureInfo.InvariantCulture)); }
      set { throw new NotImplementedException(); }
    }
    public IEnumerable<string> ColumnNames {
      get { return RowNames; }
      set { throw new NotImplementedException(); }
    }
    public bool SortableView {
      get { return false; }
      set { throw new NotImplementedException(); }
    }


    bool IStringConvertibleMatrix.Validate(string value, out string errorMessage) {
      return Validate(value, out errorMessage);
    }
    string IStringConvertibleMatrix.GetValue(int rowIndex, int columIndex) {
      return GetValue(rowIndex, columIndex);
    }
    bool IStringConvertibleMatrix.SetValue(string value, int rowIndex, int columnIndex) {
      return SetValue(value, rowIndex, columnIndex);
    }

    public event EventHandler RowsChanged;
    public event EventHandler ColumnsChanged;
    public event EventHandler RowNamesChanged;
    public event EventHandler ColumnNamesChanged;
    public event EventHandler Reset;
    public event EventHandler<EventArgs<int, int>> ItemChanged;
    public event EventHandler SortableViewChanged;

    #endregion

    #region Events
    protected void OnRowsChanged() {
      var handler = RowsChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    protected void OnColumnsChanged() {
      var handler = ColumnsChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    protected void OnRowNamesChanged() {
      var handler = RowNamesChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    protected void OnColumnNamesChanged() {
      var handler = ColumnNamesChanged;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    protected void OnReset() {
      var handler = Reset;
      if (handler != null)
        handler(this, EventArgs.Empty);
    }
    protected void OnItemChanged(int row, int col) {
      var handler = ItemChanged;
      if (handler != null) {
        handler(this, new EventArgs<int, int>(row, col));
        if (row != col)
          handler(this, new EventArgs<int, int>(col, row));
      }
    }
    #endregion
  }
}