public void IVector()
        {
            var vector3D = new Vector3D(1, 2, 8);

            var vectorN = new VectorN(3);
            vectorN.SetValues(3, 4, 2);

            var matrix = vector3D.Multiply(vectorN);

            Assert.AreEqual(3, matrix.Columns);
            Assert.AreEqual(3, matrix.Rows);

            Assert.AreEqual(3, matrix[0, 0]);
            Assert.AreEqual(4, matrix[0, 1]);
            Assert.AreEqual(2, matrix[0, 2]);

            Assert.AreEqual(6, matrix[1, 0]);
            Assert.AreEqual(8, matrix[1, 1]);
            Assert.AreEqual(4, matrix[1, 2]);

            Assert.AreEqual(24, matrix[2, 0]);
            Assert.AreEqual(32, matrix[2, 1]);
            Assert.AreEqual(16, matrix[2, 2]);

            Assert.AreEqual(1, vector3D.X);
            Assert.AreEqual(2, vector3D.Y);
            Assert.AreEqual(8, vector3D.Z);

            Assert.AreEqual(3, vectorN[0]);
            Assert.AreEqual(4, vectorN[1]);
            Assert.AreEqual(2, vectorN[2]);
        }

 public void Simple()
 {
     var vector = new VectorN(2);
     Assert.AreEqual(2, vector.DimensionCount);
     Assert.AreEqual(0, vector[0]);
     Assert.AreEqual(0, vector[1]);
 }

        public void ExceptionDifferentDimensions()
        {
            var vector1 = new VectorN(2);
            var vector2 = new VectorN(4);

            var matrix = vector1 * vector2;
        }

 public void Simple()
 {
     var visitor = new CountingVisitor<double>();
     var vector = new VectorN(2);
     vector.AcceptVisitor(visitor);
     Assert.AreEqual(2, visitor.Count);
 }

 public void Simple()
 {
     var vector1 = new VectorN(2);
     vector1.SetValues(4, 7);
     vector1.Decrement();
     Assert.AreEqual(3, vector1[0]);
     Assert.AreEqual(6, vector1[1]);
 }

 public void Double()
 {
     var vector1 = new VectorN(2);
     vector1.SetValues(9, 3);
     vector1.Divide(3);
     Assert.AreEqual(3, vector1[0]);
     Assert.AreEqual(1, vector1[1]);
 }

        public void ExceptionRightNull()
        {
            var vector1 = new VectorN(3);
            vector1.SetValues(1, 1, 1);
            const VectorN vector2 = null;

            var condition = vector1 > vector2;
        }

        public void ExceptionLeftNull()
        {
            const VectorN vector1 = null;
            var vector2 = new VectorN(3);
            vector2.SetValues(2, 2, 2);

            var condition = vector1 > vector2;
        }

 public void Completed()
 {
     var visitor = new ComparableFindingVisitor<double>(5);
     var vector = new VectorN(3);
     vector.SetValues(2, 5, 9);
     vector.AcceptVisitor(visitor);
     Assert.IsTrue(visitor.Found);
 }

 public void Double()
 {
     var vector1 = new VectorN(2);
     vector1.SetValues(4, 7);
     vector1.Add(1);
     Assert.AreEqual(5, vector1[0]);
     Assert.AreEqual(8, vector1[1]);
 }

 public void AbsoluteMinimumExample()
 {
     var vector1 = new VectorN(4);
     vector1[0] = 1;
     vector1[1] = -4;
     vector1[2] = 3;
     vector1[3] = 2;
     Assert.AreEqual(1, vector1.AbsoluteMinimum());
 }

 public void Simple()
 {
     var vector = new VectorN(3);
     vector[0] = 23;
     vector[1] = -21;
     vector[2] = 4;
     vector.Normalize();
     Assert.AreEqual(1, vector.Magnitude());
 }

 public void Simple()
 {
     var vector1 = new VectorN(4);
     vector1[0] = 1;
     vector1[1] = -4;
     vector1[2] = 3;
     vector1[3] = 2;
     Assert.AreEqual(1, vector1.MinimumIndex());
 }

 public void Simple()
 {
     var vector1 = new VectorN(4);
     vector1[0] = 1;
     vector1[1] = -4;
     vector1[2] = 3;
     vector1[3] = 2;
     Assert.AreEqual(4, vector1.AbsoluteMaximum());
 }

 public void Double()
 {
     var vector1 = new VectorN(2);
     vector1[0] = 1;
     vector1[1] = 2;
     vector1.Multiply(2);
     Assert.AreEqual(2, vector1[0]);
     Assert.AreEqual(4, vector1[1]);
 }

 public void Simple()
 {
     var vector1 = new VectorN(2);
     vector1[0] = 1;
     vector1[1] = 2;
     vector1.Negate();
     Assert.AreEqual(-1, vector1[0]);
     Assert.AreEqual(-2, vector1[1]);
 }

        public void Simple()
        {
            var vector = new VectorN(3);
            vector.SetValues(4, 3, 12);
            Assert.AreEqual(13, vector.Magnitude());

            Assert.AreEqual(4, vector[0]);
            Assert.AreEqual(3, vector[1]);
            Assert.AreEqual(12, vector[2]);
        }

 public void OperatorEqualsExample()
 {
     var vector1 = new VectorN(2);
     vector1[0] = 1;
     vector1[1] = 2;
     var vector2 = new VectorN(2);
     vector2[0] = 1;
     vector2[1] = 2;
     Assert.IsTrue(vector1 == vector2);
 }

        public void OperatorDecrementExample()
        {
            VectorBase<double> vector1 = new VectorN(2);
            vector1.SetValues(4, 7);

            vector1--;

            Assert.AreEqual(3, vector1[0]);
            Assert.AreEqual(6, vector1[1]);
        }

        public void Simple()
        {
            VectorBase<double> vector1 = new VectorN(2);
            vector1.SetValues(4, 7);

            vector1++;

            Assert.AreEqual(5, vector1[0]);
            Assert.AreEqual(8, vector1[1]);
        }