vector: added missing operators to DenseVector, added missing tests, and fixed the Gallio bug in the build file

build/build.proj

@@ -58,7 +58,7 @@
   </Target>
   
   <Target Name="CSharpTest" >
- 		<Gallio.MSBuildTasks.Gallio ContinueOnError="False" IgnoreFailures="False" Assemblies="../src/UnitTests/bin/Debug/MathNet.Numerics.UnitTests.dll"/>
+ 		<Gallio.MSBuildTasks.Gallio ContinueOnError="False" IgnoreFailures="False" Files="../src/UnitTests/bin/Debug/MathNet.Numerics.UnitTests.dll"/>
   </Target>
   
   <Target Name="BuildAndTest" DependsOnTargets="Test; Style; Gendarme"/>

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -82,7 +82,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// copying the values from another.
         /// </summary>
         /// <param name="other">
-        /// The matrix to create the new matrix from.
+        /// The vector to create the new vector from.
         /// </param>
         public DenseVector(Vector other)
             : this(other.Count)
@@ -98,6 +98,19 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             }
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DenseVector"/> class by
+        /// copying the values from another.
+        /// </summary>
+        /// <param name="other">
+        /// The vector to create the new vector from.
+        /// </param>
+        public DenseVector(DenseVector other)
+            : this(other.Count)
+        {
+            Buffer.BlockCopy(other.Data, 0, Data, 0, Data.Length * Constants.SizeOfDouble);
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DenseVector"/> class for an array.
         /// </summary>
@@ -603,10 +616,66 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             {
                 return;
             }
-
             Control.LinearAlgebraProvider.ScaleArray(scalar, Data);
         }
 
+        /// <summary>
+        /// Multiplies a vector with a scalar.
+        /// </summary>
+        /// <param name="leftSide">The vector to scale.</param>
+        /// <param name="rightSide">The scalar value.</param>
+        /// <returns>The result of the multiplication.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>
+        public static DenseVector operator *(DenseVector leftSide, double rightSide)
+        {
+            if (leftSide == null)
+            {
+                throw new ArgumentNullException("leftSide");
+            }
+
+            var ret = (DenseVector)leftSide.Clone();
+            ret.Multiply(rightSide);
+            return ret;
+        }
+
+        /// <summary>
+        /// Multiplies a vector with a scalar.
+        /// </summary>
+        /// <param name="leftSide">The scalar value.</param>
+        /// <param name="rightSide">The vector to scale.</param>
+        /// <returns>The result of the multiplication.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>
+        public static DenseVector operator *(double leftSide, DenseVector rightSide)
+        {
+            if (rightSide == null)
+            {
+                throw new ArgumentNullException("rightSide");
+            }
+
+            var ret = (DenseVector)rightSide.Clone();
+            ret.Multiply(leftSide);
+            return ret;
+        }
+
+        /// <summary>
+        /// Divides a vector with a scalar.
+        /// </summary>
+        /// <param name="leftSide">The vector to divide.</param>
+        /// <param name="rightSide">The scalar value.</param>
+        /// <returns>The result of the division.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>
+        public static DenseVector operator /(DenseVector leftSide, double rightSide)
+        {
+            if (leftSide == null)
+            {
+                throw new ArgumentNullException("leftSide");
+            }
+
+            var ret = (DenseVector)leftSide.Clone();
+            ret.Multiply(1.0 / rightSide);
+            return ret;
+        }
+
         #region Vector Norms
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs

@@ -25,19 +25,67 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
 
         [Test]
         [MultipleAsserts]
-        public void CanCreateVectorFromArray()
+        public void CanCreateDenseVectorFromArray()
         {
-            var data = new[] { 1.0, 2.0, 3.0, 4.0 };
-            var vector = new DenseVector(data);
-            Assert.AreSame(data, vector.Data);
-            for( var i = 0; i < data.Length; i++)
+            var vector = new DenseVector(_data);
+            Assert.AreSame(_data, vector.Data);
+            for (var i = 0; i < _data.Length; i++)
             {
-                Assert.AreEqual(data[i], vector[i]);
+                Assert.AreEqual(_data[i], vector[i]);
             }
             vector[0] = 100.0;
-            Assert.AreEqual(100.0, data[0]);
+            Assert.AreEqual(100.0, _data[0]);
         }
 
+        [Test]
+        [MultipleAsserts]
+        public void CanCreateDenseVectorFromAnotherDenseVector()
+        {
+            var vector = new DenseVector(_data);
+            var other = new DenseVector(vector);
+            
+            
+            Assert.AreNotSame(vector, other);
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(vector[i], other[i]);
+            }
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanCreateDenseVectorFromAnotherVector()
+        {
+            var vector = (Vector)new DenseVector(_data);
+            var other = new DenseVector(vector);
+
+            Assert.AreNotSame(vector, other);
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(vector[i], other[i]);
+            }
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanCreateDenseVectorFromUserDefinedVector()
+        {
+            var vector = new UserDefinedVector(_data);
+            var other = new DenseVector(vector);
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(vector[i], other[i]);
+            }
+        }
+
+        [Test]
+        public void CanCreateDenseVectorWithConstantValues()
+        {
+            var vector = new DenseVector(5, 5);
+            Assert.ForAll(vector, value => value == 5);
+        }
+        
         [Test]
         [MultipleAsserts]
         public void CanCreateDenseMatrix()
@@ -53,8 +101,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [MultipleAsserts]
         public void CanConvertDenseVectorToArray()
         {
-            var data = new[] { 0.0, 1.0, 2.0, 3.0, 4.0 };
-            var vector = new DenseVector(data);
+            var vector = new DenseVector(_data);
             var array = (double[])vector;
             Assert.IsInstanceOfType(typeof(double[]), array);
             Assert.AreSame(vector.Data, array);
@@ -70,5 +117,108 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             Assert.IsInstanceOfType(typeof(DenseVector), vector);
             Assert.AreElementsEqual(array, array);
         }
+
+        [Test]
+        public void CanCallUnaryPlusOperatorOnDenseVector()
+        {
+            var vector = new DenseVector(_data);
+            var other = +vector;
+            Assert.AreSame(vector, other, "Should be the same vector");
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanAddTwoDenseVectorsUsingOperator()
+        {
+            var vector = new DenseVector(_data);
+            var other = new DenseVector(_data);
+            var result = vector + other;
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i], vector[i], "Making sure the original vector wasn't modified.");
+                Assert.AreEqual(_data[i], other[i], "Making sure the original vector wasn't modified.");
+                Assert.AreEqual(_data[i] * 2.0, result[i]);
+            }
+        }
+
+        [Test]
+        public void CanCallUnaryNegationOperatorOnDenseVector()
+        {
+            var vector = new DenseVector(_data);
+            var other = -vector;
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(-_data[i], other[i]);
+            }
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanSubtractTwoDenseVectorsUsingOperator()
+        {
+            var vector = new DenseVector(_data);
+            var other = new DenseVector(_data);
+            var result = vector - other;
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i], vector[i], "Making sure the original vector wasn't modified.");
+                Assert.AreEqual(_data[i], other[i], "Making sure the original vector wasn't modified.");
+                Assert.AreEqual(0.0, result[i]);
+            }
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanMultiplyDenseVectorByScalarUsingOperators()
+        {
+            var vector = new DenseVector(_data);
+            vector = vector * 2.0;
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] * 2.0, vector[i]);
+            }
+
+            vector = vector * 1.0;
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] * 2.0, vector[i]);
+            }
+
+            vector = new DenseVector(_data);
+            vector = 2.0 * vector;
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] * 2.0, vector[i]);
+            }
+
+            vector = 1.0 * vector;
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] * 2.0, vector[i]);
+            }
+        }
+
+        [Test]
+        [MultipleAsserts]
+        public void CanDivideDenseVectorByScalarUsingOperators()
+        {
+            var vector = new DenseVector(_data);
+            vector = vector / 2.0;
+
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] / 2.0, vector[i]);
+            }
+
+            vector = vector / 1.0;
+            for (var i = 0; i < _data.Length; i++)
+            {
+                Assert.AreEqual(_data[i] / 2.0, vector[i]);
+            }
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/UserDefinedVectorTests.cs

@@ -13,6 +13,12 @@
             _data = new double[size];
         }
 
+        public UserDefinedVector(double[] data)
+            : base(data.Length)
+        {
+            _data = data;
+        }
+
         public override double this[int index]
         {
             get

src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs

@@ -10,7 +10,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
 
     public abstract partial class VectorTests
     {
-        private readonly double[] _data = {1, 2, 3, 4, 5};
+        protected readonly double[] _data = {1, 2, 3, 4, 5};
 
         [Test]
         [MultipleAsserts]
@@ -111,31 +111,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         }
 
         [Test]
-        [MultipleAsserts]
         public void CanEnumerateOverVector()
         {
             var vector = CreateVector(_data);
-            var index = 0;
+            Assert.AreElementsEqual(_data, vector);
 
-            foreach (var element in vector)
-            {
-                Assert.AreEqual(index + 1, element);
-                index++;
-            }
         }
 
         [Test]
         [MultipleAsserts]
         public void CanEnumerateOverVectorUsingIEnumerable()
         {
-            var vector = CreateVector(_data);
+            var enumerable = (IEnumerable)CreateVector(_data);
             var index = 0;
-
-            var enumerable = (IEnumerable)vector;
             foreach (var element in enumerable)
             {
-                Assert.AreEqual(index + 1, (double)element);
-                index++;
+                Assert.AreEqual(_data[index++], (double)element);
             }
         }