Unit Tests: more arithmetics covered by sparse vector theory

src/UnitTests/LinearAlgebraTests/Complex/DenseVectorArithmeticTheory.cs

@@ -44,5 +44,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
                 new DenseVector(new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1) }),
                 new DenseVector(new[] { new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0) })
             };
+
+        [Datapoints]
+        private Complex[] scalars = new[] { new Complex(2d, -1d) };
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs

@@ -46,5 +46,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
+
+        [Datapoints]
+        private Complex[] scalars = new[] { new Complex(2d, -1d) };
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorArithmeticTheory.cs

@@ -44,5 +44,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
                 new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }),
                 new DenseVector(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) })
             };
+
+        [Datapoints]
+        private Complex32[] scalars = new[] { new Complex32(2f, -1f) };
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs

@@ -46,5 +46,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
+
+        [Datapoints]
+        private Complex32[] scalars = new[] { new Complex32(2f, -1f) };
     }
 }

src/UnitTests/LinearAlgebraTests/Double/DenseVectorArithmeticTheory.cs

@@ -43,5 +43,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                 new DenseVector(new double[] { 1, 2, 3, 4, 5 }),
                 new DenseVector(new double[] { 2, 0, 0, -5, 0 }),
             };
+
+        [Datapoints]
+        private double[] scalars = new[] { 2d };
+
     }
 }

src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs

@@ -45,5 +45,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
+
+        [Datapoints]
+        private double[] scalars = new[] { 2d };
+
     }
 }

src/UnitTests/LinearAlgebraTests/Single/DenseVectorArithmeticTheory.cs

@@ -43,5 +43,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
                 new DenseVector(new float[] { 1, 2, 3, 4, 5 }),
                 new DenseVector(new float[] { 2, 0, 0, -5, 0 }),
             };
+
+        [Datapoints]
+        private float[] scalars = new[] { 2f };
     }
 }

src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs

@@ -45,5 +45,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
+
+        [Datapoints]
+        private float[] scalars = new[] { 2f };
     }
 }

src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs

@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             }
         }
 
-        [Theory, Timeout(100)]
+        [Theory, Timeout(200)]
         public void CanAddTwoVectors(Vector<T> a, Vector<T> b)
         {
             Assume.That(a.Count, Is.EqualTo(b.Count));
@@ -113,6 +113,29 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         }
 
         [Theory, Timeout(100)]
+        public void CanAddScalarToVector(Vector<T> vector, T scalar)
+        {
+            Assume.That(vector.Count, Is.LessThan(100));
+
+            var hash = vector.GetHashCode();
+
+            var result1 = vector.Add(scalar);
+            var result2 = vector.Clone();
+            result2.Add(scalar, result2);
+
+            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
+            Assert.That(result1, Is.Not.SameAs(vector));
+            Assert.That(result2, Is.Not.SameAs(vector));
+            Assert.That(result1.Equals(result2));
+
+            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
+            {
+                Assert.That(result1[i], Is.EqualTo(Add(vector[i], scalar)), i.ToString());
+                Assert.That(result2[i], Is.EqualTo(Add(vector[i], scalar)), i.ToString());
+            }
+        }
+
+        [Theory, Timeout(200)]
         public void CanSubtractTwoVectors(Vector<T> a, Vector<T> b)
         {
             Assume.That(a.Count, Is.EqualTo(b.Count));
@@ -143,5 +166,28 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
                 Assert.That(result3[i], Is.EqualTo(Subtract(a[i], b[i])), i.ToString());
             }
         }
+
+        [Theory, Timeout(100)]
+        public void CanSubtractScalarFromVector(Vector<T> vector, T scalar)
+        {
+            Assume.That(vector.Count, Is.LessThan(100));
+
+            var hash = vector.GetHashCode();
+
+            var result1 = vector.Subtract(scalar);
+            var result2 = vector.Clone();
+            result2.Subtract(scalar, result2);
+
+            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
+            Assert.That(result1, Is.Not.SameAs(vector));
+            Assert.That(result2, Is.Not.SameAs(vector));
+            Assert.That(result1.Equals(result2));
+
+            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
+            {
+                Assert.That(result1[i], Is.EqualTo(Subtract(vector[i], scalar)), i.ToString());
+                Assert.That(result2[i], Is.EqualTo(Subtract(vector[i], scalar)), i.ToString());
+            }
+        }
     }
 }