source: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs @ 16303

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.IntervalArithmetic;
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 SymbolicDataAnalysisIntervalArithmeticInterpreter : 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 SymbolicDataAnalysisIntervalArithmeticInterpreter(bool deserializing) : base(deserializing) { }

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

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

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

    private readonly object syncRoot = new object();

    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 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 (customIntervals != null && 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());
          }
        }
      }

      return new InterpreterState(code, necessaryArgStackSize);
    }

    //private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 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 (customIntervals != null && 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());
    //      }
    //      //instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
    //    } else if (instr.opCode == OpCodes.FactorVariable) {
    //      var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
    //      instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
    //    } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
    //      var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
    //      instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
    //    } else if (instr.opCode == OpCodes.LagVariable) {
    //      var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    //      instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
    //    } else if (instr.opCode == OpCodes.VariableCondition) {
    //      var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    //      instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
    //    } else if (instr.opCode == OpCodes.Call) {
    //      necessaryArgStackSize += instr.nArguments + 1;
    //    }
    //  }
    //  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.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;
          }
        //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 InterpreterState GetInstructions(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
    //  var state = PrepareInterpreterState(tree, dataset, rows, customIntervals);
    //  var x = Evaluate(dataset, state);
    //  state.Reset();
      
    //  return state;
    //}

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