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

#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) {
        return GenerateModelForExponentialTransformation();
      } 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) {
        return GenerateInverseModelForLinearTransformation();
      } else if (transformation is ExponentialTransformation) {
        return GenerateInverseModelForExponentialTransformation();
      } 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 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 GenerateInverseModelForLinearTransformation() {
      var linearTransformation = (LinearTransformation)transformation;
      var kValue = linearTransformation.Multiplier;
      var dValue = linearTransformation.Addend;

      // x - d
      var substractionNode = new Subtraction().CreateTreeNode();
      var dNode = new ConstantTreeNode(new Constant() { Name = "d" }) { Value = dValue };
      var xNode = new Variable(column, "x").CreateTreeNode();
      substractionNode.AddSubtree(xNode);
      substractionNode.AddSubtree(dNode);

      // ( x - d ) / k
      var divisionNode = new Division().CreateTreeNode();
      var kNode = new ConstantTreeNode(new Constant() { Name = "K" }) { Value = kValue };
      divisionNode.AddSubtree(substractionNode);
      divisionNode.AddSubtree(kNode);

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


    private ISymbolicExpressionTree GenerateModelForExponentialTransformation() {
      var exponentialTransformation = (ExponentialTransformation)transformation;
      var bValue = exponentialTransformation.Base;

      // b ^ x
      var powerNode = new Power().CreateTreeNode();
      var bNode = new ConstantTreeNode(new Constant() { Name = "b" }) { Value = bValue };
      var xNode = new Variable(column, "x").CreateTreeNode();
      powerNode.AddSubtree(bNode);
      powerNode.AddSubtree(xNode);

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

    private ISymbolicExpressionTree GenerateInverseModelForExponentialTransformation() {
      var exponentialTransformation = (ExponentialTransformation)transformation;
      var bValue = exponentialTransformation.Base;

      // log(x, b)
      var logNode = new Logarithm().CreateTreeNode();
      var bNode = new ConstantTreeNode(new Constant() { Name = "b" }) { Value = bValue };
      var xNode = new Variable(column, "x").CreateTreeNode();
      logNode.AddSubtree(xNode);
      logNode.AddSubtree(bNode);

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


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

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