source: branches/3133_ProblemModifiers/HeuristicLab.Problems.Modifiers/Modifier/TranscodingProblemModifier.cs

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 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 HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Optimization;

namespace HeuristicLab.Problems.Modifiers {
  [StorableType("AD8A9A90-109A-4496-A057-A94728F2C7E2")]
  [Item("TranscodingProblemModifier", "A problem modifier that converts the solution candidate for evaluation and Analysis between a new (alg sided) and an original (problem sided) encoding")]
  public abstract class TranscodingProblemModifier : ProblemModifier {
    [Storable] protected IEncoding encoding;
    [Storable] protected ISolutionCreator solutionCreator;

    public override IEncoding Encoding => encoding ?? NextModifier?.Encoding;
    public override ISolutionCreator SolutionCreator => solutionCreator ?? NextModifier?.SolutionCreator;

    #region constructors
    [StorableConstructor]
    protected TranscodingProblemModifier(StorableConstructorFlag _) : base(_) { }

    protected TranscodingProblemModifier(TranscodingProblemModifier original, Cloner cloner) : base(original, cloner) {
      encoding = cloner.Clone(original.encoding);
    }
    public TranscodingProblemModifier() { }
    #endregion

    #region ProblemModifier
    public override double[] ModifiedEvaluate(Individual individual, IRandom random) {
      var oldIndividual = ChangeIndividual(individual);
      var res = base.ModifiedEvaluate(oldIndividual, random);
      CopyIntoIndividual(oldIndividual, individual);
      return res;
    }
    public override void ModifiedAnalyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
      var oldIndividuals = individuals.Select(ChangeIndividual).ToArray();
      base.ModifiedAnalyze(oldIndividuals, qualities, results, random);
      for (var i = 0; i < oldIndividuals.Length; i++)
        CopyIntoIndividual(oldIndividuals[i], individuals[i]);
    }

    protected override void OnNextEncodingChanged(object sender, EventArgs e) {
      encoding = ChangeEncoding(NextModifier.Encoding);
      solutionCreator = ChangeSolutionCreator(NextModifier.SolutionCreator);
      InvokeEncodingChanged();
      InvokeSolutionCreatorChanged();
    }

    protected override void OnNextSolutionCreatorChanged(object sender, EventArgs e) {
      solutionCreator = ChangeSolutionCreator(NextModifier.SolutionCreator);
      InvokeSolutionCreatorChanged();
    }

    #endregion

    #region helpers
    //ChangeSolutionCreator
    protected abstract ISolutionCreator ChangeSolutionCreator(ISolutionCreator oldCreator);
    protected abstract IEncoding ChangeEncoding(IEncoding oldEncoding); //changes upwards (original enc to new enc)
    protected abstract Individual ChangeIndividual(Individual newIndividual); //changes downwards (individual with new enc to individual with original enc) 
    private static void CopyIntoIndividual(Individual oldIndividual, Individual newIndividual) { //moves additional information after evaluation or analysis to the new (alg-sided) individual
      var set = new HashSet<string>();
      foreach (var v in newIndividual.Values.Select(x => x.Key)) set.Add(v);
      foreach (var v in oldIndividual.Values.Where(v1 => !set.Contains(v1.Key))) newIndividual[v.Key] = v.Value;
    }
    #endregion
  }
}