LA: diagonal OfArray

src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs

@@ -136,6 +136,33 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// The array to copy from must be diagonal as well.
         /// A new memory block will be allocated for storing the matrix.
         /// </summary>
+        public static DiagonalMatrix OfArray(Complex[,] array)
+        {
+            var storage = new DiagonalMatrixStorage<Complex>(array.GetLength(0), array.GetLength(1));
+            for (var i = 0; i < storage.RowCount; i++)
+            {
+                for (var j = 0; j < storage.ColumnCount; j++)
+                {
+                    if (i == j)
+                    {
+                        storage.Data[i] = array[i, j];
+                    }
+                    else if (((array[i, j].Real != 0d) && !double.IsNaN(array[i, j].Real)) || ((array[i, j].Imaginary != 0d) && !double.IsNaN(array[i, j].Imaginary)))
+                    {
+                        throw new IndexOutOfRangeException("Cannot set an off-diagonal element in a diagonal matrix.");
+                    }
+                }
+            }
+            return new DiagonalMatrix(storage);
+        }
+
+        /// <summary>
+        /// Create a new diagonal matrix as a copy of the given two-dimensional array.
+        /// This new matrix will be independent from the provided array.
+        /// The array to copy from must be diagonal as well.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        [Obsolete("Use DiagonalMatrix.OfArray instead. Scheduled for removal in v3.0.")]
         public DiagonalMatrix(Complex[,] array)
             : this(array.GetLength(0), array.GetLength(1))
         {

src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs

@@ -136,6 +136,33 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// The array to copy from must be diagonal as well.
         /// A new memory block will be allocated for storing the matrix.
         /// </summary>
+        public static DiagonalMatrix OfArray(Complex32[,] array)
+        {
+            var storage = new DiagonalMatrixStorage<Complex32>(array.GetLength(0), array.GetLength(1));
+            for (var i = 0; i < storage.RowCount; i++)
+            {
+                for (var j = 0; j < storage.ColumnCount; j++)
+                {
+                    if (i == j)
+                    {
+                        storage.Data[i] = array[i, j];
+                    }
+                    else if (((array[i, j].Real != 0f) && !float.IsNaN(array[i, j].Real)) || ((array[i, j].Imaginary != 0f) && !float.IsNaN(array[i, j].Imaginary)))
+                    {
+                        throw new IndexOutOfRangeException("Cannot set an off-diagonal element in a diagonal matrix.");
+                    }
+                }
+            }
+            return new DiagonalMatrix(storage);
+        }
+
+        /// <summary>
+        /// Create a new diagonal matrix as a copy of the given two-dimensional array.
+        /// This new matrix will be independent from the provided array.
+        /// The array to copy from must be diagonal as well.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        [Obsolete("Use DiagonalMatrix.OfArray instead. Scheduled for removal in v3.0.")]
         public DiagonalMatrix(Complex32[,] array)
             : this(array.GetLength(0), array.GetLength(1))
         {

src/Numerics/LinearAlgebra/Double/DiagonalMatrix.cs

@@ -135,6 +135,33 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// The array to copy from must be diagonal as well.
         /// A new memory block will be allocated for storing the matrix.
         /// </summary>
+        public static DiagonalMatrix OfArray(double[,] array)
+        {
+            var storage = new DiagonalMatrixStorage<double>(array.GetLength(0), array.GetLength(1));
+            for (var i = 0; i < storage.RowCount; i++)
+            {
+                for (var j = 0; j < storage.ColumnCount; j++)
+                {
+                    if (i == j)
+                    {
+                        storage.Data[i] = array[i, j];
+                    }
+                    else if (array[i, j] != 0d && !double.IsNaN(array[i, j]))
+                    {
+                        throw new IndexOutOfRangeException("Cannot set an off-diagonal element in a diagonal matrix.");
+                    }
+                }
+            }
+            return new DiagonalMatrix(storage);
+        }
+
+        /// <summary>
+        /// Create a new diagonal matrix as a copy of the given two-dimensional array.
+        /// This new matrix will be independent from the provided array.
+        /// The array to copy from must be diagonal as well.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        [Obsolete("Use DiagonalMatrix.OfArray instead. Scheduled for removal in v3.0.")]
         public DiagonalMatrix(double[,] array)
             : this(array.GetLength(0), array.GetLength(1))
         {

src/Numerics/LinearAlgebra/Single/DiagonalMatrix.cs

@@ -135,6 +135,33 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// The array to copy from must be diagonal as well.
         /// A new memory block will be allocated for storing the matrix.
         /// </summary>
+        public static DiagonalMatrix OfArray(float[,] array)
+        {
+            var storage = new DiagonalMatrixStorage<float>(array.GetLength(0), array.GetLength(1));
+            for (var i = 0; i < storage.RowCount; i++)
+            {
+                for (var j = 0; j < storage.ColumnCount; j++)
+                {
+                    if (i == j)
+                    {
+                        storage.Data[i] = array[i, j];
+                    }
+                    else if (array[i, j] != 0f && !float.IsNaN(array[i, j]))
+                    {
+                        throw new IndexOutOfRangeException("Cannot set an off-diagonal element in a diagonal matrix.");
+                    }
+                }
+            }
+            return new DiagonalMatrix(storage);
+        }
+
+        /// <summary>
+        /// Create a new diagonal matrix as a copy of the given two-dimensional array.
+        /// This new matrix will be independent from the provided array.
+        /// The array to copy from must be diagonal as well.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        [Obsolete("Use DiagonalMatrix.OfArray instead. Scheduled for removal in v3.0.")]
         public DiagonalMatrix(float[,] array)
             : this(array.GetLength(0), array.GetLength(1))
         {

src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs

@@ -82,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix CreateMatrix(Complex[,] data)
         {
-            return new DiagonalMatrix(data);
+            return DiagonalMatrix.OfArray(data);
         }
 
         /// <summary>
@@ -151,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = new DiagonalMatrix(TestData2D[name]);
+            var matrix = DiagonalMatrix.OfArray(TestData2D[name]);
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)

src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs

@@ -82,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix CreateMatrix(Complex32[,] data)
         {
-            return new DiagonalMatrix(data);
+            return DiagonalMatrix.OfArray(data);
         }
 
         /// <summary>
@@ -151,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = new DiagonalMatrix(TestData2D[name]);
+            var matrix = DiagonalMatrix.OfArray(TestData2D[name]);
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)

src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs

@@ -81,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix CreateMatrix(double[,] data)
         {
-            return new DiagonalMatrix(data);
+            return DiagonalMatrix.OfArray(data);
         }
 
         /// <summary>
@@ -150,7 +150,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = new DiagonalMatrix(TestData2D[name]);
+            var matrix = DiagonalMatrix.OfArray(TestData2D[name]);
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)

src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs

@@ -81,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix CreateMatrix(float[,] data)
         {
-            return new DiagonalMatrix(data);
+            return DiagonalMatrix.OfArray(data);
         }
 
         /// <summary>
@@ -150,7 +150,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = new DiagonalMatrix(TestData2D[name]);
+            var matrix = DiagonalMatrix.OfArray(TestData2D[name]);
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)