diff --git a/src/UnitTests/LinearAlgebraTests/Complex/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex/VectorArithmeticTheory.cs
index 5b24e634..0ca9cebc 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/VectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/VectorArithmeticTheory.cs
@@ -30,127 +30,13 @@
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
 {
-    using System;
     using System.Numerics;
-    using LinearAlgebra.Generic;
     using NUnit.Framework;
 
     [TestFixture]
-    public abstract class VectorArithmeticTheory
+    public abstract class VectorArithmeticTheory : VectorArithmeticTheory<Complex>
     {
-        [Theory, Timeout(100)]
-        public void CanCallUnaryPlusOperatorOnVector(Vector<Complex> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = +vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That(result.Equals(vector));
-        }
-
-        [Theory, Timeout(100)]
-        public void CanCallUnaryMinusOperatorOnVector(Vector<Complex> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = -vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That((-result).Equals(vector));
-
-            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(-vector[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsUsingOperator(Vector<Complex> a, Vector<Complex> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a + b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsInplace(Vector<Complex> a, Vector<Complex> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Add(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsUsingOperator(Vector<Complex> a, Vector<Complex> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a - b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsInplace(Vector<Complex> a, Vector<Complex> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Subtract(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
+        protected override Complex Minus(Complex value) { return -value; }
+        protected override Complex Add(Complex first, Complex second) { return first + second; }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex32/VectorArithmeticTheory.cs
index 3f1def91..9165c673 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/VectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/VectorArithmeticTheory.cs
@@ -30,127 +30,13 @@
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
 {
-    using System;
-    using LinearAlgebra.Generic;
     using Numerics;
     using NUnit.Framework;
 
     [TestFixture]
-    public abstract class VectorArithmeticTheory
+    public abstract class VectorArithmeticTheory : VectorArithmeticTheory<Complex32>
     {
-        [Theory, Timeout(100)]
-        public void CanCallUnaryPlusOperatorOnVector(Vector<Complex32> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = +vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That(result.Equals(vector));
-        }
-
-        [Theory, Timeout(100)]
-        public void CanCallUnaryMinusOperatorOnVector(Vector<Complex32> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = -vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That((-result).Equals(vector));
-
-            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(-vector[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsUsingOperator(Vector<Complex32> a, Vector<Complex32> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a + b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsInplace(Vector<Complex32> a, Vector<Complex32> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Add(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsUsingOperator(Vector<Complex32> a, Vector<Complex32> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a - b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsInplace(Vector<Complex32> a, Vector<Complex32> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Subtract(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
+        protected override Complex32 Minus(Complex32 value) { return -value; }
+        protected override Complex32 Add(Complex32 first, Complex32 second) { return first + second; }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Double/VectorArithmeticTheory.cs
index 4af0b317..99ae0394 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/VectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/VectorArithmeticTheory.cs
@@ -30,126 +30,12 @@
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
 {
-    using System;
-    using LinearAlgebra.Generic;
     using NUnit.Framework;
 
     [TestFixture]
-    public abstract class VectorArithmeticTheory
+    public abstract class VectorArithmeticTheory : VectorArithmeticTheory<double>
     {
-        [Theory] //, Timeout(100)]
-        public void CanCallUnaryPlusOperatorOnVector(Vector<double> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = +vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That(result.Equals(vector));
-        }
-
-        [Theory, Timeout(100)]
-        public void CanCallUnaryMinusOperatorOnVector(Vector<double> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = -vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That((-result).Equals(vector));
-
-            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(-vector[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsUsingOperator(Vector<double> a, Vector<double> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a + b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsInplace(Vector<double> a, Vector<double> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Add(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsUsingOperator(Vector<double> a, Vector<double> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a - b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsInplace(Vector<double> a, Vector<double> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Subtract(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
+        protected override double Minus(double value) { return -value; }
+        protected override double Add(double first, double second) { return first + second; }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Single/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Single/VectorArithmeticTheory.cs
index 56c4f8c5..4b825aa7 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/VectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/VectorArithmeticTheory.cs
@@ -30,126 +30,12 @@
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
 {
-    using System;
-    using LinearAlgebra.Generic;
     using NUnit.Framework;
 
     [TestFixture]
-    public abstract class VectorArithmeticTheory
+    public abstract class VectorArithmeticTheory : VectorArithmeticTheory<float>
     {
-        [Theory, Timeout(100)]
-        public void CanCallUnaryPlusOperatorOnVector(Vector<float> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = +vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That(result.Equals(vector));
-        }
-
-        [Theory, Timeout(100)]
-        public void CanCallUnaryMinusOperatorOnVector(Vector<float> vector)
-        {
-            var hash = vector.GetHashCode();
-
-            var result = -vector;
-
-            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
-            Assert.That(result, Is.Not.SameAs(vector));
-            Assert.That((-result).Equals(vector));
-
-            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(-vector[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsUsingOperator(Vector<float> a, Vector<float> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a + b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanAddTwoVectorsInplace(Vector<float> a, Vector<float> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Add(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] + b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsUsingOperator(Vector<float> a, Vector<float> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a - b;
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
-
-        [Theory, Timeout(100)]
-        public void CanSubtractTwoVectorsInplace(Vector<float> a, Vector<float> b)
-        {
-            Assume.That(a.Count, Is.EqualTo(b.Count));
-
-            var hasha = a.GetHashCode();
-            var hashb = b.GetHashCode();
-
-            var result = a.Clone();
-            result.Subtract(b, result);
-
-            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
-            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
-            Assert.That(result, Is.Not.SameAs(a));
-            Assert.That(result, Is.Not.SameAs(b));
-
-            for (var i = 0; i < Math.Min(a.Count, 20); i++)
-            {
-                Assert.That(result[i], Is.EqualTo(a[i] - b[i]), i.ToString());
-            }
-        }
+        protected override float Minus(float value) { return -value; }
+        protected override float Add(float first, float second) { return first + second; }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs
new file mode 100644
index 00000000..4b5338ea
--- /dev/null
+++ b/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs
@@ -0,0 +1,160 @@
+// <copyright file="VectorArithmeticTheory.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://numerics.mathdotnet.com
+// http://github.com/mathnet/mathnet-numerics
+// http://mathnetnumerics.codeplex.com
+//
+// Copyright (c) 2009-2011 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
+{
+    using System;
+    using LinearAlgebra.Generic;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public abstract class VectorArithmeticTheory<T>
+        where T : struct, IEquatable<T>, IFormattable
+    {
+        protected abstract T Minus(T value);
+        protected abstract T Add(T first, T second);
+        private T Subtract(T first, T second) { return Add(first, Minus(second)); }
+
+        [Theory, Timeout(100)]
+        public void CanCloneVectorUsingUnaryPlusOperator(Vector<T> vector)
+        {
+            var hash = vector.GetHashCode();
+
+            var result = +vector;
+
+            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
+            Assert.That(result, Is.Not.SameAs(vector));
+            Assert.That(result.Equals(vector));
+        }
+
+        [Theory, Timeout(100)]
+        public void CanNegateVectorUsingUnaryMinusOperator(Vector<T> vector)
+        {
+            var hash = vector.GetHashCode();
+
+            var result = -vector;
+
+            Assert.That(vector.GetHashCode(), Is.EqualTo(hash));
+            Assert.That(result, Is.Not.SameAs(vector));
+            Assert.That((-result).Equals(vector));
+
+            for (var i = 0; i < Math.Min(vector.Count, 20); i++)
+            {
+                Assert.That(result[i], Is.EqualTo(Minus(vector[i])), i.ToString());
+            }
+        }
+
+        [Theory, Timeout(100)]
+        public void CanAddTwoVectorsUsingOperator(Vector<T> a, Vector<T> b)
+        {
+            Assume.That(a.Count, Is.EqualTo(b.Count));
+
+            var hasha = a.GetHashCode();
+            var hashb = b.GetHashCode();
+
+            var result = a + b;
+
+            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
+            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
+            Assert.That(result, Is.Not.SameAs(a));
+            Assert.That(result, Is.Not.SameAs(b));
+
+            for (var i = 0; i < Math.Min(a.Count, 20); i++)
+            {
+                Assert.That(result[i], Is.EqualTo(Add(a[i], b[i])), i.ToString());
+            }
+        }
+
+        [Theory, Timeout(100)]
+        public void CanAddTwoVectorsInplace(Vector<T> a, Vector<T> b)
+        {
+            Assume.That(a.Count, Is.EqualTo(b.Count));
+
+            var hasha = a.GetHashCode();
+            var hashb = b.GetHashCode();
+
+            var result = a.Clone();
+            result.Add(b, result);
+
+            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
+            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
+            Assert.That(result, Is.Not.SameAs(a));
+            Assert.That(result, Is.Not.SameAs(b));
+
+            for (var i = 0; i < Math.Min(a.Count, 20); i++)
+            {
+                Assert.That(result[i], Is.EqualTo(Add(a[i], b[i])), i.ToString());
+            }
+        }
+
+        [Theory, Timeout(100)]
+        public void CanSubtractTwoVectorsUsingOperator(Vector<T> a, Vector<T> b)
+        {
+            Assume.That(a.Count, Is.EqualTo(b.Count));
+
+            var hasha = a.GetHashCode();
+            var hashb = b.GetHashCode();
+
+            var result = a - b;
+
+            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
+            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
+            Assert.That(result, Is.Not.SameAs(a));
+            Assert.That(result, Is.Not.SameAs(b));
+
+            for (var i = 0; i < Math.Min(a.Count, 20); i++)
+            {
+                Assert.That(result[i], Is.EqualTo(Subtract(a[i], b[i])), i.ToString());
+            }
+        }
+
+        [Theory, Timeout(100)]
+        public void CanSubtractTwoVectorsInplace(Vector<T> a, Vector<T> b)
+        {
+            Assume.That(a.Count, Is.EqualTo(b.Count));
+
+            var hasha = a.GetHashCode();
+            var hashb = b.GetHashCode();
+
+            var result = a.Clone();
+            result.Subtract(b, result);
+
+            Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
+            Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
+            Assert.That(result, Is.Not.SameAs(a));
+            Assert.That(result, Is.Not.SameAs(b));
+
+            for (var i = 0; i < Math.Min(a.Count, 20); i++)
+            {
+                Assert.That(result[i], Is.EqualTo(Subtract(a[i], b[i])), i.ToString());
+            }
+        }
+    }
+}
diff --git a/src/UnitTests/UnitTests.csproj b/src/UnitTests/UnitTests.csproj
index 251a057a..8408f2b2 100644
--- a/src/UnitTests/UnitTests.csproj
+++ b/src/UnitTests/UnitTests.csproj
@@ -717,6 +717,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="LinearAlgebraTests\Double\VectorArithmeticTheory.cs" />
+    <Compile Include="LinearAlgebraTests\VectorArithmeticTheory.cs" />
     <Compile Include="NumberTheoryTests\GcdRelatedTest.cs" />
     <Compile Include="NumberTheoryTests\GcdRelatedTestBigInteger.cs" />
     <Compile Include="NumberTheoryTests\IntegerTheoryTest.cs" />