Allow empty Vector and Matrix

src/Numerics.Tests/LinearAlgebraTests/Complex/VectorTests.cs

@@ -63,7 +63,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             Assert.AreEqual(vector.Count, clone.Count);
             CollectionAssert.AreEqual(vector, clone);
         }
-        
+
         /// <summary>
         /// Can clone a vector using <c>IClonable</c> interface method.
         /// </summary>
@@ -198,7 +198,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void SizeIsNotPositiveThrowsArgumentOutOfRangeException()
         {
             Assert.That(() => CreateVector(-1), Throws.TypeOf<ArgumentOutOfRangeException>());
-            Assert.That(() => CreateVector(0), Throws.TypeOf<ArgumentOutOfRangeException>());
         }
 
         /// <summary>

src/Numerics.Tests/LinearAlgebraTests/Complex32/VectorTests.cs

@@ -63,7 +63,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             Assert.AreEqual(vector.Count, clone.Count);
             CollectionAssert.AreEqual(vector, clone);
         }
-        
+
         /// <summary>
         /// Can clone a vector using <c>IClonable</c> interface method.
         /// </summary>
@@ -198,7 +198,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void SizeIsNotPositiveThrowsArgumentOutOfRangeException()
         {
             Assert.That(() => CreateVector(-1), Throws.TypeOf<ArgumentOutOfRangeException>());
-            Assert.That(() => CreateVector(0), Throws.TypeOf<ArgumentOutOfRangeException>());
         }
 
         /// <summary>

src/Numerics.Tests/LinearAlgebraTests/Double/VectorTests.cs

@@ -59,7 +59,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             Assert.AreEqual(vector.Count, clone.Count);
             CollectionAssert.AreEqual(vector, clone);
         }
-        
+
         /// <summary>
         /// Can clone a vector using <c>IClonable</c> interface method.
         /// </summary>
@@ -194,7 +194,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void SizeIsNotPositiveThrowsArgumentOutOfRangeException()
         {
             Assert.That(() => CreateVector(-1), Throws.TypeOf<ArgumentOutOfRangeException>());
-            Assert.That(() => CreateVector(0), Throws.TypeOf<ArgumentOutOfRangeException>());
         }
 
         /// <summary>

src/Numerics.Tests/LinearAlgebraTests/MatrixTests.cs

@@ -0,0 +1,77 @@
+// <copyright file="VectorStorageCombinatorsTests.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://numerics.mathdotnet.com
+// http://github.com/mathnet/mathnet-numerics
+//
+// Copyright (c) 2009-2016 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>
+
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Storage;
+using NUnit.Framework;
+
+namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
+{
+    [TestFixture, Category("LA")]
+    public class MatrixTests
+    {
+        [Test]
+        public void DenseMatrixBuilderMethos_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Dense(0, 0));
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Dense(0, 0, 42));
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Dense(0, 0, Array.Empty<double>()));
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Dense(0, 0, (row, column) => 42));
+        }
+
+        [Test]
+        public void SparseMatrixBuilderMethos_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Sparse(0, 0));
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Sparse(0, 0, 42));
+            Assert.DoesNotThrow(() => Matrix<double>.Build.Sparse(0, 0, (row, column) => 42));
+        }
+
+        [Test]
+        public void DenseColumnMajorMatrixStorageBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => new DenseColumnMajorMatrixStorage<double>(0, 0));
+            Assert.DoesNotThrow(() => new DenseColumnMajorMatrixStorage<double>(0, 0, Array.Empty<double>()));
+        }
+
+        [Test]
+        public void DiagonalMatrixStorageBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => new DiagonalMatrixStorage<double>(0, 0));
+            Assert.DoesNotThrow(() => new DiagonalMatrixStorage<double>(0, 0, Array.Empty<double>()));
+        }
+
+        [Test]
+        public void SparseCompressedRowMatrixStorageBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => new SparseCompressedRowMatrixStorage<double>(0, 0));
+        }
+    }
+}

src/Numerics.Tests/LinearAlgebraTests/Single/VectorTests.cs

@@ -60,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             Assert.AreEqual(vector.Count, clone.Count);
             CollectionAssert.AreEqual(vector, clone);
         }
-        
+
         /// <summary>
         /// Can clone a vector using <c>IClonable</c> interface method.
         /// </summary>
@@ -195,7 +195,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void SizeIsNotPositiveThrowsArgumentOutOfRangeException()
         {
             Assert.That(() => CreateVector(-1), Throws.TypeOf<ArgumentOutOfRangeException>());
-            Assert.That(() => CreateVector(0), Throws.TypeOf<ArgumentOutOfRangeException>());
         }
 
         /// <summary>

src/Numerics.Tests/LinearAlgebraTests/VectorTests.cs

@@ -0,0 +1,107 @@
+// <copyright file="VectorStorageCombinatorsTests.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://numerics.mathdotnet.com
+// http://github.com/mathnet/mathnet-numerics
+//
+// Copyright (c) 2009-2016 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>
+
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Storage;
+using MathNet.Numerics.Properties;
+using NUnit.Framework;
+
+namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
+{
+    [TestFixture, Category("LA")]
+    public class VectorTests
+    {
+        [Test]
+        public void DenseVectorBuilderMethod_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => Vector<double>.Build.Dense(0));
+            Assert.DoesNotThrow(() => Vector<double>.Build.Dense(0, 42));
+            Assert.DoesNotThrow(() => Vector<double>.Build.Dense(0, index => 42));
+            Assert.DoesNotThrow(() => Vector<double>.Build.Dense(Array.Empty<double>()));
+        }
+
+        [Test]
+        public void SparseVectorBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => Vector<double>.Build.Sparse(0));
+            Assert.DoesNotThrow(() => Vector<double>.Build.Sparse(0, 42));
+            Assert.DoesNotThrow(() => Vector<double>.Build.Sparse(0, index => 42));
+        }
+
+        [Test]
+        public void DenseVectorStorageBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => new DenseVectorStorage<double>(0));
+            Assert.DoesNotThrow(() => new DenseVectorStorage<double>(0, Array.Empty<double>()));
+            Assert.DoesNotThrow(() => DenseVectorStorage<double>.OfValue(0, 42));
+            Assert.DoesNotThrow(() => DenseVectorStorage<double>.OfInit(0, index => 42));
+        }
+
+        [Test]
+        public void SparseVectorStorageBuilderMethods_ZeroLength_DoNotThrowException()
+        {
+            Assert.DoesNotThrow(() => new SparseVectorStorage<double>(0));
+            Assert.DoesNotThrow(() => SparseVectorStorage<double>.OfValue(0, 42));
+            Assert.DoesNotThrow(() => SparseVectorStorage<double>.OfInit(0, index => 42));
+        }
+
+        [Test]
+        public void DenseVectorStorageOfInit_NegativeLength_ThrowsArgumentException()
+        {
+            Assert.That(() => DenseVectorStorage<double>.OfInit(-1, index => 42),
+                Throws.TypeOf<ArgumentOutOfRangeException>()
+                .With.Message.Contains(Resources.ArgumentNotNegative));
+        }
+
+        [Test]
+        public void DenseVectorStorageOfValue_NegativeLength_ThrowsArgumentException()
+        {
+            Assert.That(() => DenseVectorStorage<double>.OfValue(-1, 42),
+                Throws.TypeOf<ArgumentOutOfRangeException>()
+                .With.Message.Contains(Resources.ArgumentNotNegative));
+        }
+
+        [Test]
+        public void SparseVectorStorageOfInit_NegativeLength_ThrowsArgumentException()
+        {
+            Assert.That(() => SparseVectorStorage<double>.OfInit(-1, index => 42),
+                Throws.TypeOf<ArgumentOutOfRangeException>()
+                .With.Message.Contains(Resources.ArgumentNotNegative));
+        }
+
+        [Test]
+        public void SparseVectorStorageOfValue_NegativeLength_ThrowsArgumentException()
+        {
+            Assert.That(() => SparseVectorStorage<double>.OfValue(-1, 42),
+                Throws.TypeOf<ArgumentOutOfRangeException>()
+                .With.Message.Contains(Resources.ArgumentNotNegative));
+        }
+    }
+}

src/Numerics/LinearAlgebra/Storage/DenseVectorStorage.cs

@@ -115,9 +115,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
 
         public static DenseVectorStorage<T> OfValue(int length, T value)
         {
-            if (length < 1)
+            if (length < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(length), string.Format(Resources.ArgumentLessThanOne, length));
+                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentNotNegative);
             }
 
             var data = new T[length];
@@ -133,9 +133,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
 
         public static DenseVectorStorage<T> OfInit(int length, Func<int, T> init)
         {
-            if (length < 1)
+            if (length < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(length), string.Format(Resources.ArgumentLessThanOne, length));
+                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentNotNegative);
             }
 
             var data = new T[length];

src/Numerics/LinearAlgebra/Storage/MatrixStorage.cs

@@ -51,12 +51,12 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
 
         protected MatrixStorage(int rowCount, int columnCount)
         {
-            if (rowCount <= 0)
+            if (rowCount < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(rowCount), Resources.MatrixRowsMustBePositive);
             }
 
-            if (columnCount <= 0)
+            if (columnCount < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(columnCount), Resources.MatrixColumnsMustBePositive);
             }

src/Numerics/LinearAlgebra/Storage/SparseVectorStorage.cs

@@ -315,9 +315,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
                 return new SparseVectorStorage<T>(length);
             }
 
-            if (length < 1)
+            if (length < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(length), string.Format(Resources.ArgumentLessThanOne, length));
+                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentNotNegative);
             }
 
             var indices = new int[length];
@@ -338,9 +338,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
 
         public static SparseVectorStorage<T> OfInit(int length, Func<int, T> init)
         {
-            if (length < 1)
+            if (length < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(length), string.Format(Resources.ArgumentLessThanOne, length));
+                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentNotNegative);
             }
 
             var indices = new List<int>();

src/Numerics/LinearAlgebra/Storage/VectorStorage.cs

@@ -48,9 +48,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
 
         protected VectorStorage(int length)
         {
-            if (length <= 0)
+            if (length < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentMustBePositive);
+                throw new ArgumentOutOfRangeException(nameof(length), Resources.ArgumentNotNegative);
             }
 
             Length = length;