source: branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/Intervalnterpreter.cs @ 16326

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;

namespace HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.Interpreter {
  [StorableClass]
  [Item("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.")]
  public class IntervalInterpreter : ParameterizedNamedItem{
    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
    }

    public int EvaluatedSolutions {
      get { return EvaluatedSolutionsParameter.Value.Value; }
      set { EvaluatedSolutionsParameter.Value.Value = value; }
    }

    public void ClearState() { }

    protected IntervalInterpreter(bool deserializing) : base(deserializing) { }

    protected IntervalInterpreter(IntervalInterpreter original,
        Cloner cloner)
        : base(original, cloner) { }

    public IntervalInterpreter()
        : base("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.") { }

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

    private readonly object syncRoot = new object();

    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, 
      IEnumerable<int> rows, IDataset dataset = null, Dictionary<string, Interval> customIntervals = null) {
      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
      int necessaryArgStackSize = 0;
      
      foreach(Instruction instr in code) {
        if (instr.opCode == OpCodes.Variable) {
          var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
          IList<double> values = new List<double>();

          if (dataset != null && customIntervals != null) {
            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) {
              instr.data = customIntervals[variableTreeNode.VariableName];
            } else {
              foreach (var rowEnum in rows) {
                values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
              }
              instr.data = new Interval(values.Min(), values.Max());
            }
          } else if (dataset != null) {
             foreach (var rowEnum in rows) {
              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
            }
            instr.data = new Interval(values.Min(), values.Max());
          } else if (customIntervals != null) {
            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) { 
              instr.data = customIntervals[variableTreeNode.VariableName];
            }
          } else {
            throw new Exception("No valid input for variables!");
          }
        }
      }

      return new InterpreterState(code, necessaryArgStackSize);
    }

    private Interval Evaluate(InterpreterState state, Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
      Instruction currentInstr = state.NextInstruction();
      switch (currentInstr.opCode) {
        //Elementary arithmetic rules
        case OpCodes.Add: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Add(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Sub: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Subtract(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Mul: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Multiply(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Div: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Divide(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        //Trigonometric functions
        case OpCodes.Sin: {
            var s = Interval.Sine(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Cos: {
            var s = Interval.Cosine(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Tan: {
            var s = Interval.Tangens(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        //Exponential functions
        case OpCodes.Log: {
            var s = Interval.Logarithm(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Exp: {
            var s = Interval.Exponential(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Power: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Power(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Square: {
            var s = Interval.Square(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.Root: {
            var s = Evaluate(state, intervals);
            for (int i = 1; i < currentInstr.nArguments; i++) {
              s = Interval.Root(s, Evaluate(state, intervals));
            }
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        case OpCodes.SquareRoot: {
            var s = Interval.SquareRoot(Evaluate(state, intervals));
            intervals.Add(currentInstr.dynamicNode, s);
            return s;
          }
        //Variables, Constants, ...
        case OpCodes.Variable: {
            intervals.Add(currentInstr.dynamicNode, (Interval)currentInstr.data);
            return (Interval)currentInstr.data;
          }
        case OpCodes.Constant: {
            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
            var inter = new Interval(constTreeNode.Value, constTreeNode.Value);
            intervals.Add(currentInstr.dynamicNode, inter);
            return inter;
          }
        default:
          throw new NotSupportedException();
      }
    }

    public void InitializeState() {
      EvaluatedSolutions = 0;
    }

    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IEnumerable<int> rows, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
      var state = PrepareInterpreterState(tree, rows);
      var x = Evaluate(state, intervals);

      return x;
    }

    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows,
      Dictionary<string, Interval> customIntervals, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
      var state = PrepareInterpreterState(tree, rows, dataset, customIntervals);
      var x = Evaluate(state, intervals);

      return x;
    }

    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 
      out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
      var state = PrepareInterpreterState(tree, rows, dataset);
      var x = Evaluate(state, intervals);
      
      return x;
    }
  }
}