source: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs @ 9204

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.ConditionActionEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Encodings.VariableVector {
  [StorableClass]
  [Item("VariableVector", "")]
  public class VariableVector : Item, IClassifier {

    [Storable]
    protected VariableVectorCondition condition;
    public VariableVectorCondition Condition { get { return condition; } }

    [Storable]
    protected VariableVectorAction action;
    public VariableVectorAction Action { get { return action; } }

    public int Count {
      get { return condition.Count + action.Count; }
    }

    public int VirtualLength {
      get { return condition.Values.Sum(x => x.VirtualLength) + action.Values.Sum(x => x.VirtualLength); }
    }

    [StorableConstructor]
    protected VariableVector(bool deserializing) : base(deserializing) { }
    protected VariableVector(VariableVector original, Cloner cloner)
      : base(original, cloner) {
      condition = new VariableVectorCondition(original.condition);
      action = new VariableVectorAction(original.action);
    }
    public VariableVector() {
      condition = new VariableVectorCondition();
      action = new VariableVectorAction();
    }
    public VariableVector(IEnumerable<IVariable> condition, IEnumerable<IVariable> action)
      : this() {
      if (condition == null || action == null) { throw new ArgumentNullException(); }
      if (action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
      this.Condition.Add(condition);
      this.Action.Add(action.Cast<IActionVariable>());
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new VariableVector(this, cloner);
    }

    public override string ToString() {
      StringBuilder sb = new StringBuilder();
      sb.Append("[");
      sb.Append(condition.ToString());
      sb.Append("||");
      sb.Append(action.ToString());
      sb.Append("]");
      return sb.ToString();
    }

    public void Randomize(IRandom random, double spreadPercentage) {
      condition.Randomize(random, spreadPercentage);
      action.Randomize(random);
    }

    ICondition IClassifier.Condition {
      get { return Condition; }
    }

    IAction IClassifier.Action {
      get { return Action; }
    }

    public bool MatchInput(IInput target) {
      return Condition.Match(target);
    }

    public bool MatchAction(IAction target) {
      return Action.Match(target);
    }

    public bool IsMoreGeneral(IClassifier target) {
      return IsMoreGeneral(target.Condition);
    }

    public bool IsMoreGeneral(ICondition target) {
      var targetCast = target as VariableVector;
      if (targetCast == null) { return false; }
      if (Condition.Keys.Except(targetCast.Condition.Keys).Count() != 0
        || targetCast.Condition.Keys.Except(Condition.Keys).Count() != 0) { return false; }

      double thisGenerality = Condition.Values.Sum(x => x.GetGenerality());
      double targetGenerality = Condition.Values.Sum(x => x.GetGenerality());
      if (thisGenerality <= targetGenerality) { return false; }

      foreach (var variables in targetCast.Condition) {
        if (!Condition[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
          return false;
        }
      }
      return true;
    }

    public bool Identical(IClassifier target) {
      var targetCast = target as VariableVector;
      if (targetCast == null) { return false; }
      if (!condition.Identical(targetCast.condition)) { return false; }
      if (!action.Identical(targetCast.condition)) { return false; }
      return true;
    }

    [StorableClass]
    [Item("VariableVectorActionComparer", "")]
    public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {

      [StorableConstructor]
      protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
      protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
        : base(original, cloner) {
      }
      public override IDeepCloneable Clone(Cloner cloner) {
        return new VariableVectorActionComparer(this, cloner);
      }
      public VariableVectorActionComparer() : base() { }

      public bool Equals(VariableVectorAction x, VariableVectorAction y) {
        throw new NotImplementedException();
      }

      public int GetHashCode(VariableVectorAction obj) {
        throw new NotImplementedException();
      }

      public bool Equals(IAction x, IAction y) {
        var xCast = x as VariableVectorAction;
        var yCast = y as VariableVectorAction;
        return x != null && y != null && Equals(xCast, yCast);
      }

      public int GetHashCode(IAction obj) {
        var objCast = obj as VariableVectorAction;
        return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
      }
    }
  }
}