private ISymbolicExpressionTreeNode ParseIntegral(Queue <Token> tokens)
        {
            Token varTok = tokens.Dequeue();

            Debug.Assert(varTok.StringValue == "INTEGRAL");
            LaggedTreeNode t = (LaggedTreeNode)integral.CreateTreeNode();

            t.Lag = (int)tokens.Dequeue().DoubleValue;
            return(t);
        }
        private ISymbolicExpressionTreeNode ParseTimeLag(Queue <Token> tokens)
        {
            Token varTok = tokens.Dequeue();

            Debug.Assert(varTok.StringValue == "LAG");
            LaggedTreeNode t = (LaggedTreeNode)timeLag.CreateTreeNode();

            t.Lag = (int)tokens.Dequeue().DoubleValue;
            return(t);
        }
 protected LaggedTreeNode(LaggedTreeNode original, Cloner cloner)
     : base(original, cloner)
 {
     lag = original.lag;
 }
Example #4
0
        private void CompileInstructions(ILGenerator il, InterpreterState state, IDataset ds)
        {
            Instruction currentInstr = state.NextInstruction();
            int         nArgs        = currentInstr.nArguments;

            switch (currentInstr.opCode)
            {
            case OpCodes.Add: {
                if (nArgs > 0)
                {
                    CompileInstructions(il, state, ds);
                }
                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Add);
                }
                return;
            }

            case OpCodes.Sub: {
                if (nArgs == 1)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Neg);
                    return;
                }
                if (nArgs > 0)
                {
                    CompileInstructions(il, state, ds);
                }
                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Sub);
                }
                return;
            }

            case OpCodes.Mul: {
                if (nArgs > 0)
                {
                    CompileInstructions(il, state, ds);
                }
                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Mul);
                }
                return;
            }

            case OpCodes.Div: {
                if (nArgs == 1)
                {
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Div);
                    return;
                }
                if (nArgs > 0)
                {
                    CompileInstructions(il, state, ds);
                }
                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Div);
                }
                return;
            }

            case OpCodes.Average: {
                CompileInstructions(il, state, ds);
                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Add);
                }
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, nArgs);
                il.Emit(System.Reflection.Emit.OpCodes.Div);
                return;
            }

            case OpCodes.Cos: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
                return;
            }

            case OpCodes.Sin: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
                return;
            }

            case OpCodes.Tan: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
                return;
            }

            case OpCodes.Power: {
                CompileInstructions(il, state, ds);
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, round);
                il.Emit(System.Reflection.Emit.OpCodes.Call, power);
                return;
            }

            case OpCodes.Root: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, round);
                il.Emit(System.Reflection.Emit.OpCodes.Div);
                il.Emit(System.Reflection.Emit.OpCodes.Call, power);
                return;
            }

            case OpCodes.Exp: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
                return;
            }

            case OpCodes.Log: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, log);
                return;
            }

            case OpCodes.Square: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
                il.Emit(System.Reflection.Emit.OpCodes.Call, power);
                return;
            }

            case OpCodes.SquareRoot: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
                return;
            }

            case OpCodes.AiryA: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
                return;
            }

            case OpCodes.AiryB: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
                return;
            }

            case OpCodes.Bessel: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
                return;
            }

            case OpCodes.CosineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
                return;
            }

            case OpCodes.Dawson: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
                return;
            }

            case OpCodes.Erf: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
                return;
            }

            case OpCodes.ExponentialIntegralEi: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
                return;
            }

            case OpCodes.FresnelCosineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
                return;
            }

            case OpCodes.FresnelSineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
                return;
            }

            case OpCodes.Gamma: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
                return;
            }

            case OpCodes.HyperbolicCosineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
                return;
            }

            case OpCodes.HyperbolicSineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
                return;
            }

            case OpCodes.Norm: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
                return;
            }

            case OpCodes.Psi: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
                return;
            }

            case OpCodes.SineIntegral: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
                return;
            }

            case OpCodes.IfThenElse: {
                Label end = il.DefineLabel();
                Label c1  = il.DefineLabel();
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
                il.Emit(System.Reflection.Emit.OpCodes.Cgt);
                il.Emit(System.Reflection.Emit.OpCodes.Brfalse, c1);
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Br, end);
                il.MarkLabel(c1);
                CompileInstructions(il, state, ds);
                il.MarkLabel(end);
                return;
            }

            case OpCodes.AND: {
                Label falseBranch = il.DefineLabel();
                Label end         = il.DefineLabel();
                CompileInstructions(il, state, ds);
                for (int i = 1; i < nArgs; i++)
                {
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
                    il.Emit(System.Reflection.Emit.OpCodes.Cgt);
                    il.Emit(System.Reflection.Emit.OpCodes.Brfalse, falseBranch);
                    CompileInstructions(il, state, ds);
                }
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
                il.Emit(System.Reflection.Emit.OpCodes.Cgt);
                il.Emit(System.Reflection.Emit.OpCodes.Brfalse, falseBranch);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1
                il.Emit(System.Reflection.Emit.OpCodes.Br, end);
                il.MarkLabel(falseBranch);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // -1
                il.Emit(System.Reflection.Emit.OpCodes.Neg);
                il.MarkLabel(end);
                return;
            }

            case OpCodes.OR: {
                Label trueBranch   = il.DefineLabel();
                Label end          = il.DefineLabel();
                Label resultBranch = il.DefineLabel();
                CompileInstructions(il, state, ds);
                for (int i = 1; i < nArgs; i++)
                {
                    Label nextArgBranch = il.DefineLabel();
                    // complex definition because of special properties of NaN
                    il.Emit(System.Reflection.Emit.OpCodes.Dup);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // <= 0
                    il.Emit(System.Reflection.Emit.OpCodes.Ble, nextArgBranch);
                    il.Emit(System.Reflection.Emit.OpCodes.Br, resultBranch);
                    il.MarkLabel(nextArgBranch);
                    il.Emit(System.Reflection.Emit.OpCodes.Pop);
                    CompileInstructions(il, state, ds);
                }
                il.MarkLabel(resultBranch);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
                il.Emit(System.Reflection.Emit.OpCodes.Cgt);
                il.Emit(System.Reflection.Emit.OpCodes.Brtrue, trueBranch);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // -1
                il.Emit(System.Reflection.Emit.OpCodes.Neg);
                il.Emit(System.Reflection.Emit.OpCodes.Br, end);
                il.MarkLabel(trueBranch);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1
                il.MarkLabel(end);
                return;
            }

            case OpCodes.NOT: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);    // > 0
                il.Emit(System.Reflection.Emit.OpCodes.Cgt);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                il.Emit(System.Reflection.Emit.OpCodes.Neg);         // * -1
                return;
            }

            case OpCodes.XOR: {
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
                il.Emit(System.Reflection.Emit.OpCodes.Cgt);// > 0

                for (int i = 1; i < nArgs; i++)
                {
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
                    il.Emit(System.Reflection.Emit.OpCodes.Cgt);// > 0
                    il.Emit(System.Reflection.Emit.OpCodes.Xor);
                }
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                return;
            }

            case OpCodes.GT: {
                CompileInstructions(il, state, ds);
                CompileInstructions(il, state, ds);

                il.Emit(System.Reflection.Emit.OpCodes.Cgt);         // 1 (>) / 0 (otherwise)
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                return;
            }

            case OpCodes.LT: {
                CompileInstructions(il, state, ds);
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Clt);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                return;
            }

            case OpCodes.TimeLag: {
                LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
                il.Emit(System.Reflection.Emit.OpCodes.Add);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                var prevLaggedContext = state.InLaggedContext;
                state.InLaggedContext = true;
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row += lag
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                state.InLaggedContext = prevLaggedContext;
                return;
            }

            case OpCodes.Integral: {
                int            savedPc        = state.ProgramCounter;
                LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
                il.Emit(System.Reflection.Emit.OpCodes.Add);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                var prevLaggedContext = state.InLaggedContext;
                state.InLaggedContext = true;
                CompileInstructions(il, state, ds);
                for (int l = laggedTreeNode.Lag; l < 0; l++)
                {
                    il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row += lag
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
                    il.Emit(System.Reflection.Emit.OpCodes.Add);
                    il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                    state.ProgramCounter = savedPc;
                    CompileInstructions(il, state, ds);
                    il.Emit(System.Reflection.Emit.OpCodes.Add);
                }
                state.InLaggedContext = prevLaggedContext;
                return;
            }

            //mkommend: derivate calculation taken from:
            //http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/
            //one sided smooth differentiatior, N = 4
            // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
            case OpCodes.Derivative: {
                int savedPc = state.ProgramCounter;
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row --
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_M1);
                il.Emit(System.Reflection.Emit.OpCodes.Add);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                state.ProgramCounter = savedPc;
                var prevLaggedContext = state.InLaggedContext;
                state.InLaggedContext = true;
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // f_0 + 2 * f_1
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Add);

                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -=2
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_2);
                il.Emit(System.Reflection.Emit.OpCodes.Sub);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                state.ProgramCounter = savedPc;
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // f_0 + 2 * f_1 - 2 * f_3
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Sub);

                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row --
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_M1);
                il.Emit(System.Reflection.Emit.OpCodes.Add);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                state.ProgramCounter = savedPc;
                CompileInstructions(il, state, ds);
                il.Emit(System.Reflection.Emit.OpCodes.Sub);         // f_0 + 2 * f_1 - 2 * f_3 - f_4
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 8.0); // / 8
                il.Emit(System.Reflection.Emit.OpCodes.Div);

                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row +=4
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_4);
                il.Emit(System.Reflection.Emit.OpCodes.Add);
                il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
                state.InLaggedContext = prevLaggedContext;
                return;
            }

            case OpCodes.Call: {
                throw new NotSupportedException(
                          "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
            }

            case OpCodes.Arg: {
                throw new NotSupportedException(
                          "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
            }

            case OpCodes.Variable: {
                VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.data);
                // load correct column of the current variable
                il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
                if (!state.InLaggedContext)
                {
                    il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
                    il.Emit(System.Reflection.Emit.OpCodes.Mul);
                }
                else
                {
                    var nanResult    = il.DefineLabel();
                    var normalResult = il.DefineLabel();
                    il.Emit(System.Reflection.Emit.OpCodes.Dup);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
                    il.Emit(System.Reflection.Emit.OpCodes.Blt, nanResult);
                    il.Emit(System.Reflection.Emit.OpCodes.Dup);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
                    il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
                    il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
                    il.Emit(System.Reflection.Emit.OpCodes.Mul);
                    il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
                    il.MarkLabel(nanResult);
                    il.Emit(System.Reflection.Emit.OpCodes.Pop); // rowIndex
                    il.Emit(System.Reflection.Emit.OpCodes.Pop); // column reference
                    il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
                    il.MarkLabel(normalResult);
                }
                return;
            }

            case OpCodes.LagVariable: {
                var nanResult    = il.DefineLabel();
                var normalResult = il.DefineLabel();
                LaggedVariableTreeNode varNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.data);
                // load correct column of the current variable
                il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
                il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);             // rowIndex
                il.Emit(System.Reflection.Emit.OpCodes.Add);                 // actualRowIndex = rowIndex + sampleOffset
                il.Emit(System.Reflection.Emit.OpCodes.Dup);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
                il.Emit(System.Reflection.Emit.OpCodes.Blt, nanResult);
                il.Emit(System.Reflection.Emit.OpCodes.Dup);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
                il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
                il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
                il.Emit(System.Reflection.Emit.OpCodes.Mul);
                il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
                il.MarkLabel(nanResult);
                il.Emit(System.Reflection.Emit.OpCodes.Pop); // sample index
                il.Emit(System.Reflection.Emit.OpCodes.Pop); // column reference
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
                il.MarkLabel(normalResult);
                return;
            }

            case OpCodes.Constant: {
                ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
                il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
                return;
            }

            //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
            //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
            case OpCodes.VariableCondition: {
                throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
                                                " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
            }

            default:
                throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
                                                " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
            }
        }
Example #5
0
 protected LaggedTreeNode(LaggedTreeNode original, Cloner cloner)
   : base(original, cloner) {
   lag = original.lag;
 }