source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingContext.cs @ 10676

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2013 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 HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using Variable = HeuristicLab.Problems.DataAnalysis.Symbolic.Variable;

namespace HeuristicLab.DataPreprocessing {
  [Item("PreprocessingContext", "PreprocessingContext")]
  public class PreprocessingContext
    : Item, IPreprocessingContext {

    public ITransactionalPreprocessingData Data { get; private set; }

    public IDataAnalysisProblemData DataAnalysisProblemData { get; private set; }

    public IAlgorithm Algorithm { get; private set; }

    public IDataAnalysisProblem Problem { get; private set; }

    public PreprocessingContext(IDataAnalysisProblemData dataAnalysisProblemData, IAlgorithm algorithm, IDataAnalysisProblem problem) {
      Data = new TransactionalPreprocessingData(dataAnalysisProblemData);
      DataAnalysisProblemData = dataAnalysisProblemData;
      Algorithm = algorithm;
      Problem = problem;
    }

    private PreprocessingContext(PreprocessingContext original, Cloner cloner)
      : base(original, cloner) {
      Data = cloner.Clone(original.Data);
      DataAnalysisProblemData = original.DataAnalysisProblemData;
      Algorithm = original.Algorithm;
      Problem = original.Problem;
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new PreprocessingContext(this, cloner);
    }

    public IItem ExportAlgorithmOrProblem() {
      if (Algorithm != null) {
        return ExportAlgorithm();
      }
      return ExportProblem();
    }

    public IProblem ExportProblem() {
      return Export(Problem, SetupProblem);
    }
    public IAlgorithm ExportAlgorithm() {
      return Export(Algorithm, SetupAlgorithm);
    }

    private IDataAnalysisProblem SetupProblem(IProblem problem) {
      return (IDataAnalysisProblem)problem;
    }
    private IDataAnalysisProblem SetupAlgorithm(IAlgorithm algorithm) {
      algorithm.Name = algorithm.Name + "(Preprocessed)";
      algorithm.Runs.Clear();
      return (IDataAnalysisProblem)algorithm.Problem;
    }
    private T Export<T>(T original, Func<T, IDataAnalysisProblem> setup)
        where T : IItem {
      var creator = new ProblemDataCreator(this);
      var data = creator.CreateProblemData();

      var clone = (T)original.Clone(new Cloner());

      var problem = setup(clone);
      problem.ProblemDataParameter.ActualValue = data;
      problem.Name = "Preprocessed " + problem.Name;

      var symbolicProblem = problem as ISymbolicDataAnalysisProblem;
      if (symbolicProblem != null) {
        var tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
        var variableNode = (VariableTreeNode)new Variable("dummy", "dummy description").CreateTreeNode();
        variableNode.VariableName = "dummy";
        tree.Root.AddSubtree(variableNode);

        symbolicProblem.TransformationsParameter.Value.Add(tree);
      }

      return clone;
    }
  }
}