source: branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TransformationToSymbolicTreeMapper.cs @ 10846

#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.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Problems.DataAnalysis.Transformations;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  public class TransformationToSymbolicTreeMapper : ITransformationMapper<ISymbolicExpressionTree> {
    private ITransformation transformation;
    private string column;
    private ISymbolicExpressionTree tree;

    #region ITransformationMapper<ISymbolicExpressionTree> Members

    public ISymbolicExpressionTree GenerateModel(ITransformation transformation) {
      InitComponents(transformation);

      if (transformation is LinearTransformation) {
        return GenerateModelForLinearTransformation();
      } else if (transformation is ExponentialTransformation) {

      } else if (transformation is LogarithmicTransformation) {

      } else if (transformation is PowerTransformation) {

      } else if (transformation is ReciprocalTransformation) {

      } else if (transformation is ShiftStandardDistributionTransformation) {

      }
      throw new NotImplementedException();
    }

    public ISymbolicExpressionTree GenerateInverseModel(ITransformation transformation) {
      InitComponents(transformation);

      if (transformation is LinearTransformation) {

      } else if (transformation is ExponentialTransformation) {

      } else if (transformation is LogarithmicTransformation) {

      } else if (transformation is PowerTransformation) {

      } else if (transformation is ReciprocalTransformation) {

      } else if (transformation is ShiftStandardDistributionTransformation) {

      }

      throw new NotImplementedException();
    }

    #endregion

    private ISymbolicExpressionTree GenerateModelForLinearTransformation() {
      var linearTransformation = (LinearTransformation)transformation;
      var tree = CreateNewTree();
      string column = linearTransformation.Column;
      var kValue = linearTransformation.Multiplier;
      var dValue = linearTransformation.Addend;

      // k * x
      var multiplicationNode = new Multiplication().CreateTreeNode();
      var kNode = new ConstantTreeNode(new Constant() { Name = "K" }) { Value = kValue };
      var xNode = new Variable(column, "x").CreateTreeNode();
      multiplicationNode.AddSubtree(kNode);
      multiplicationNode.AddSubtree(xNode);

      // ( k * x ) + d
      var additionNode = new Addition().CreateTreeNode();
      var dNode = new ConstantTreeNode(new Constant() { Name = "d" }) { Value = dValue };
      additionNode.AddSubtree(multiplicationNode);
      additionNode.AddSubtree(dNode);

      tree.Root.AddSubtree(additionNode);
      return tree;
    }

    private ISymbolicExpressionTree CreateNewTree() {
      return new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
    }

    private void InitComponents(ITransformation transformation) {
      this.transformation = transformation;
      column = transformation.Column;
      tree = CreateNewTree();
    }
  }
}