source: branches/HeuristicLab.Algorithms.IteratedSentenceConstruction/HeuristicLab.Algorithms.IteratedSymbolicExpressionConstruction/3.3/QualityFunctions/TabularMaxQualityFunction.cs @ 12909

using System;
using System.Collections.Generic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Algorithms.IteratedSymbolicExpressionConstruction {
  [StorableClass]
  [Item("TabularMaxQualityFunction", "")]
  internal class TabularMaxQualityFunction : ParameterizedNamedItem, ITabularQualityFunction {
    [Storable]
    private readonly Dictionary<object, Dictionary<int, double>> q = new Dictionary<object, Dictionary<int, double>>();
    [Storable]
    private readonly Dictionary<object, Dictionary<int, int>> tries = new Dictionary<object, Dictionary<int, int>>();

    public IStateFunction StateFunction {
      get {
        return ((IValueParameter<IStateFunction>)Parameters["State function"]).Value;
      }
      set { ((IValueParameter<IStateFunction>)Parameters["State function"]).Value = value; }
    }

    public TabularMaxQualityFunction() {
      Parameters.Add(new ValueParameter<IStateFunction>("State function", "The function that is used to map partial trees to states", new DefaultStateFunction()));
    }

    public double Q(object state, int action) {
      // an action that has never been tried has q == infinity
      Dictionary<int, double> stateActionQualities;
      if (!q.TryGetValue(state, out stateActionQualities)) return double.PositiveInfinity;
      double quality;
      if (!stateActionQualities.TryGetValue(action, out quality)) return double.PositiveInfinity;
      return quality;
    }

    public void Update(object state, int action, double observedQuality) {
      Dictionary<int, int> stateActionTries;
      if (!tries.TryGetValue(state, out stateActionTries)) {
        stateActionTries = new Dictionary<int, int>();
        tries.Add(state, stateActionTries);
      }
      Dictionary<int, double> stateActionQualities = null;
      if (!q.TryGetValue(state, out stateActionQualities)) {
        stateActionQualities = new Dictionary<int, double>();
        q.Add(state, stateActionQualities);
      }
      int t;
      if (!stateActionTries.TryGetValue(action, out t)) {
        t = 0;
        stateActionTries.Add(action, t + 1);
        stateActionQualities.Add(action, observedQuality);
      } else {
        stateActionTries[action] = t + 1;
        stateActionQualities[action] = Math.Max(stateActionQualities[action], observedQuality);
      }
    }

    public int Tries(object state, int action) {
      Dictionary<int, int> stateTries;
      if (!tries.TryGetValue(state, out stateTries)) return 0;
      int stateActionTries;
      if (!stateTries.TryGetValue(action, out stateActionTries)) return 0;
      return stateActionTries;
    }

    #region item
    [StorableConstructor]
    protected TabularMaxQualityFunction(bool deserializing) : base(deserializing) { }
    protected TabularMaxQualityFunction(TabularMaxQualityFunction original, Cloner cloner)
      : base(original, cloner) {
      this.q = new Dictionary<object, Dictionary<int, double>>(original.q);
      this.tries = new Dictionary<object, Dictionary<int, int>>(original.tries);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new TabularMaxQualityFunction(this, cloner);
    }
    #endregion

    public void InitializeState() {
      ClearState();
    }

    public void ClearState() {
      q.Clear();
      tries.Clear();
    }
  }
}