source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/Fragments/SymbolicExpressionTreeFragmentLengthsAnalyzer.cs @ 9238

#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.Collections.Generic;
using System.Linq;
using HeuristicLab.Analysis;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
// type definitions for convenience
using CloneMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItem>;
using TraceMapType = HeuristicLab.Core.ItemDictionary<HeuristicLab.Core.IItem, HeuristicLab.Core.IItemList<HeuristicLab.Core.IItem>>;

namespace HeuristicLab.EvolutionaryTracking {
  /// <summary>
  /// An operator that gathers information on tree fragments that get passed from one generation to the next via genetic operators
  /// (Tracking of genetic variance and heredity)
  /// </summary>
  [Item("SymbolicExpressionTreeFragmentLengthAnalyzer", "An operator that provides statistics about fragment lengths")]
  [StorableClass]
  public sealed class SymbolicExpressionTreeFragmentLengthAnalyzer : SymbolicExpressionTreeFragmentsAnalyzer {
    private const string FragmentLengthsParameterName = "Fragment Lengths";
    // impact values calculator
    public ILookupParameter<DataTable> FragmentLengthsParameter { get { return (ILookupParameter<DataTable>)Parameters[FragmentLengthsParameterName]; } }
    public DataTable FragmentLengths {
      get { return FragmentLengthsParameter.ActualValue; }
      set { FragmentLengthsParameter.ActualValue = value; }
    }

    [StorableConstructor]
    private SymbolicExpressionTreeFragmentLengthAnalyzer(bool deserializing) : base(deserializing) { }
    private SymbolicExpressionTreeFragmentLengthAnalyzer(SymbolicExpressionTreeFragmentLengthAnalyzer original, Cloner cloner) : base(original, cloner) { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new SymbolicExpressionTreeFragmentLengthAnalyzer(this, cloner);
    }
    public SymbolicExpressionTreeFragmentLengthAnalyzer()
      : base() {
      #region Add parameters
      Parameters.Add(new LookupParameter<DataTable>(FragmentLengthsParameterName));
      #endregion

      UpdateCounterParameter.Hidden = true;
      UpdateIntervalParameter.Hidden = true;
    }
    #region After deserialization code
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    #endregion
    #region IStatefulItem members
    public override void InitializeState() {
      base.InitializeState();
      UpdateCounter.Value = 0;
    }

    public override void ClearState() {
      base.ClearState();
      UpdateCounter.Value = 0;
    }
    #endregion

    public override IOperation Apply() {
      UpdateCounter.Value++;
      if (UpdateCounter.Value == UpdateInterval.Value) {
        UpdateCounter.Value = 0; // reset counter
        if (Generations.Value > 1) {
          SecondaryTraceMap = SecondaryTraceMap ?? new TraceMapType();
          SecondaryFragmentMap = SecondaryFragmentMap ?? new CloneMapType();
          SecondaryCloneMap = SecondaryCloneMap ?? new CloneMapType();

          InitializeParameters();
          InitializeRows();

          var fragmentLengths = (from m in SecondaryFragmentMap
                                 let fragment = (IFragment)m.Value
                                 where fragment.Root != null
                                 select fragment.Length
                               ).ToList();

          // fragments of selected offspring
          var selected = new HashSet<ISymbolicExpressionTree>(GlobalTraceMap.Values.SelectMany(list => list.Cast<ISymbolicExpressionTree>()));
          var goodFragmentlengths = (from m in SecondaryFragmentMap
                                     let tree = (ISymbolicExpressionTree)m.Key
                                     let fragment = (IFragment)m.Value
                                     where fragment.Root != null
                                     where selected.Contains(tree)
                                     select fragment.Length
                                    ).ToList();

          FragmentLengths.Rows["Average fragment length (all)"].Values.Add(fragmentLengths.Count > 0 ? fragmentLengths.Average() : 0.0);
          FragmentLengths.Rows["Average fragment length (good)"].Values.Add(goodFragmentlengths.Count > 0 ? goodFragmentlengths.Average() : 0.0);
        }
      }
      return base.Apply();
    }

    protected override void InitializeParameters() {
      var results = ResultsParameter.ActualValue;
      if (!results.ContainsKey("Fragment lengths")) {
        FragmentLengths = FragmentLengths ?? new DataTable("Fragment lengths") { VisualProperties = { YAxisTitle = "Number of nodes" } };
        results.Add(new Result("Fragment lengths", FragmentLengths));
      }
      base.InitializeParameters();
    }

    private void InitializeRows() {
      string[] rowNames =
        {
          "Average fragment length (good)", "Average fragment length (all)"
        };
      foreach (var rowName in rowNames.Where(rowName => !FragmentLengths.Rows.ContainsKey(rowName))) {
        FragmentLengths.Rows.Add(new DataRow(rowName) { VisualProperties = { StartIndexZero = true } });
      }
    }
  } //SymbolicExpressionTreeFragmentLengthAnalyzer
}