public void OrIsShortcircuit()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression dividebyzero = new BinaryOperatorExpression(new ConstantExpression(1), new ConstantExpression(0), BinaryOperator.Divide);

            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, dividebyzero, BooleanOperator.Or)).Evaluate(null));
        }

        public Node Parse()
        {
            Expression curExpr = null;
            for (; ; ) {
                _tokens.MoveNext();
                Token t = _tokens.Current;

                switch (t.Kind) {
                    case TokenKinds.EOF:
                        return curExpr;
                    case TokenKinds.Operator:
                        if (curExpr == null) {
                            throw new SyntaxErrorException("expected value before operator");
                        }

                        curExpr = ActionExpression.Operator(((OperatorToken)t).DlrOperator,
                            curExpr,
                            (Expression)Parse());
                        break;
                    case TokenKinds.Constant:
                        curExpr = new ConstantExpression(((ConstantToken)t).Value);
                        break;
                }
            }
        }

        public void CreateNotExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            NotExpression expression = new NotExpression(trueexpr);

            Assert.AreEqual(trueexpr, expression.Expression);
        }

        public void AndIsShortcircuit()
        {
            IExpression falseexpr = new ConstantExpression(false);
            IExpression dividebyzero = new BinaryOperatorExpression(new ConstantExpression(1), new ConstantExpression(0), BinaryOperator.Divide);

            Assert.IsFalse((bool)(new BooleanExpression(falseexpr, dividebyzero, BooleanOperator.And)).Evaluate(null));
        }

        public void EvaluateNotExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);

            Assert.IsFalse((bool)(new NotExpression(trueexpr)).Evaluate(null));
            Assert.IsTrue((bool)(new NotExpression(falseexpr)).Evaluate(null));
        }

        public void SetVariable()
        {
            IExpression expression = new ConstantExpression(1);
            BindingEnvironment environment = new BindingEnvironment();
            ICommand command = new SetCommand("spam", expression);
            command.Execute(environment);

            Assert.AreEqual(1, environment.GetValue("spam"));
        }

        public void EvaluateOr()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);

            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, trueexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsTrue((bool)(new BooleanExpression(trueexpr, falseexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsTrue((bool)(new BooleanExpression(falseexpr, trueexpr, BooleanOperator.Or)).Evaluate(null));
            Assert.IsFalse((bool)(new BooleanExpression(falseexpr, falseexpr, BooleanOperator.Or)).Evaluate(null));
        }

        public void CreateBooleanExpression()
        {
            IExpression trueexpr = new ConstantExpression(true);
            IExpression falseexpr = new ConstantExpression(false);
            BooleanExpression expression = new BooleanExpression(trueexpr, falseexpr, BooleanOperator.Or);

            Assert.AreEqual(trueexpr, expression.Left);
            Assert.AreEqual(falseexpr, expression.Right);

            Assert.AreEqual(BooleanOperator.Or, expression.Operation);
        }

        public void CreateSetIndexCommand()
        {
            IExpression targetExpression = new ConstantExpression(1);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);

            Assert.AreEqual(targetExpression, command.TargetExpression);
            Assert.AreEqual(indexExpression, command.IndexExpression);
            Assert.AreEqual(valueExpression, command.Expression);
        }

        public void CreateSetCommand()
        {
            IExpression expression = new ConstantExpression("bar");
            SetCommand command = new SetCommand("foo", expression);

            Assert.IsNotNull(command);
            Assert.IsNotNull(command.Target);
            Assert.IsNotNull(command.Expression);

            Assert.AreEqual("foo", command.Target);
            Assert.AreEqual(expression, command.Expression);
        }

        public void ExecuteSetIndexCommandOnList()
        {
            var list = new List<object>() { 1, 2, 2 };
            IExpression targetExpression = new ConstantExpression(list);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual(3, list[2]);
        }

        public void AConstant_ShouldReturnTheConstantValue()
        {
            // Arrange
            var expectedValue = 3;
            var sut = new ConstantExpression(expectedValue);

            // Act
            var actual = sut.Eval();

            // Assert
            Assert.AreEqual(expectedValue, actual);
        }

        public void ExecuteSetIndexCommandOnArray()
        {
            var array = new object[] { 1, 2, 2 };
            IExpression targetExpression = new ConstantExpression(array);
            IExpression indexExpression = new ConstantExpression(2);
            IExpression valueExpression = new ConstantExpression(3);

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual(3, array[2]);
        }

        public void ExecuteSetIndexCommandOnDictionary()
        {
            var dictionary = new Hashtable();
            IExpression targetExpression = new ConstantExpression(dictionary);
            IExpression indexExpression = new ConstantExpression("foo");
            IExpression valueExpression = new ConstantExpression("bar");

            var command = new SetIndexCommand(targetExpression, indexExpression, valueExpression);
            command.Execute(null);

            Assert.AreEqual("bar", dictionary["foo"]);
        }

        /// <summary>
        /// Performs reverse-mode (adjoint) automatic differentiation 
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="dependentVariable"></param>
        /// <param name="independentVariables"></param>
        public static void Differentiate(BlockExpressionBuilder builder, 
            out IList<Expression> derivativeExpressions,
            VectorParameterExpression dependentVariable,
            params VectorParameterExpression[] independentVariables)
        {
            if (independentVariables.Length == 0)
            {
                derivativeExpressions = null;
                return;
            }

            var block = builder.ToBlock();
            // change the numbering of variables; arguments first, then locals
            List<int>[] jLookup;
            Function[] f;

            // we want a list of functions which can be unary or binary (in principle high order if it makes sense) and a look-up
            // each function is associated with a parameter, which is either an argument or a local
            // for each function index we return a list of the indices of the functions that reference the parameter
            GetFunctions(block, out f, out jLookup);

            int N = dependentVariable.Index;

            bool[] derivativeRequired; int[] derivativeExpressionIndex;
            IdentifyNeccesaryDerivatives(N, jLookup, independentVariables, out derivativeRequired, out derivativeExpressionIndex);

            // the list of operations needed to calculate the derivatives (*all* derivatives)
            derivativeExpressions = new Expression[independentVariables.Length];
            var dxNdx = new Expression[N + 1];
            dxNdx[N] = new ConstantExpression<double>(1.0);
            for (int i = N - 1; i >= 0; i--)
            {
                if (!derivativeRequired[i]) continue;
                // dxN / dxi
                // need to find all operation indices j such that p(j) contains i
                // that is, all functions that have xi as an argument (these must therefore have a higher index than i)
                VectorParameterExpression total = new ConstantExpression<double>(0);
                var xi = f[i].Parameter;
                //need sum of dfj/dxi dXN/dxj
                foreach (var j in jLookup[i])
                {
                    var fj = f[j];
                    var dfjdxi = Differentiate(fj, xi, builder); // dfj/dxi
                    var dXNdxj = dxNdx[j]; // dXN/dxj
                    var product = builder.AddProductExpression(dfjdxi, dXNdxj);
                    total = builder.AddAdditionExpression(total, product);
                }
                dxNdx[i] = total;
                int targetIndex = derivativeExpressionIndex[i];
                if (targetIndex != -1) derivativeExpressions[targetIndex] = total;
            }
        }

 /// <summary>
 /// Adds the specified constant expression.
 /// </summary>
 /// <param name="constantExpression">The constant expression.</param>
 /// <param name="exponent">The exponent.</param>
 public void Add(ConstantExpression constantExpression, double exponent)
 {
     var additionalConstant = Math.Pow(constantExpression.Constant, exponent);
     if (this.constantFlatIdentifierRepresentation == null)
     {
         this.constantFlatIdentifierRepresentation = new ConstantFlatIdentifierRepresentation(additionalConstant);
         this.additionalCount++;
     }
     else
     {
         this.constantFlatIdentifierRepresentation =
             new ConstantFlatIdentifierRepresentation(
                 this.constantFlatIdentifierRepresentation.Constant * additionalConstant);
     }
 }

        static void Main(string[] args)
        {
            IArithmeticVisitor visitor = new ConsoleArithmeticVisitor();

            IArithmeticExpression leftInnerNode = new ConstantExpression(39);
            IArithmeticExpression rightInnerNode = new ConstantExpression(13);

            IArithmeticExpression leftNode = new ConstantExpression(15);
            IArithmeticExpression rightNode = new SubtractionExpression(leftInnerNode, rightInnerNode);

            IArithmeticExpression rootNode = new MultiplicationExpression(leftNode, new BracketsExpression(rightNode));

            rootNode.Accept(visitor);

            Console.WriteLine();
        }

 public virtual void PostWalk(ConstantExpression node) { }

 // ConstantExpression
 public virtual bool Walk(ConstantExpression node) { return true; }

        public void ExpressionsEnumerable(object value, int blockSize)
        {
            ConstantExpression[] values = new ConstantExpression[blockSize];
            for (int i = 0; i != values.Length; ++i)
                values[i] = Expression.Constant(value);

            BlockExpression block = Expression.Block(SingleParameter, values);

            Assert.True(values.SequenceEqual(block.Expressions));
            int index = 0;
            foreach (Expression exp in ((IEnumerable)block.Expressions))
                Assert.Same(exp, values[index++]);
        }