added methods to create matrices from a list of vectors. work items: 5691

src/Numerics/LinearAlgebra/Generic/Matrix.cs

@@ -44,9 +44,9 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
 #if SILVERLIGHT
     IFormattable, IEquatable<Matrix<T>>
 #else
-    IFormattable, IEquatable<Matrix<T>>, ICloneable
+        IFormattable, IEquatable<Matrix<T>>, ICloneable
 #endif
-    where T : struct, IEquatable<T>, IFormattable
+        where T : struct, IEquatable<T>, IFormattable
     {
         /// <summary>
         /// Initializes a new instance of the Matrix class.
@@ -110,6 +110,82 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
             private set;
         }
 
+        /// <summary>
+        /// Constructs matrix from a list of column vectors.
+        /// </summary>
+        /// <param name="columnVectors">The vectors to construct the matrix from.</param>
+        /// <returns>The matrix constructed from the list of column vectors.</returns>
+        /// <remarks>Creates a matrix of size Max(<paramref name="columnVectors"/>[i].Count) x <paramref name="columnVectors"/>.Count</remarks>
+        public static Matrix<T> CreateFromColumns(IList<Vector<T>> columnVectors)
+        {
+            if (columnVectors == null)
+            {
+                throw new ArgumentNullException("columnVectors");
+            }
+
+            if (columnVectors.Count == 0)
+            {
+                throw new ArgumentOutOfRangeException("columnVectors");
+            }
+
+            var rows = columnVectors[0].Count;
+            var columns = columnVectors.Count;
+
+            for (var column = 1; column < columns; column++)
+            {
+                rows = Math.Max(rows, columnVectors[column].Count);
+            }
+
+            var matrix = columnVectors[0].CreateMatrix(rows, columns);
+            for (var j = 0; j < columns; j++)
+            {
+                for (var i = 0; i < columnVectors[j].Count; i++)
+                {
+                    matrix.At(i, j, columnVectors[j][i]);
+                }
+            }
+
+            return matrix;
+        }
+
+        /// <summary>
+        /// Constructs matrix from a list of  row vectors.
+        /// </summary>
+        /// <param name="rowVectors">The vectors to construct the matrix from.</param>
+        /// <returns>The matrix constructed from the list of row vectors.</returns>
+        /// <remarks>Creates a matrix of size Max(<paramref name="rowVectors"/>.Count) x <paramref name="rowVectors"/>[i].Count</remarks>
+        public static Matrix<T> CreateFromRows(IList<Vector<T>> rowVectors)
+        {
+            if (rowVectors == null)
+            {
+                throw new ArgumentNullException("rowVectors");
+            }
+
+            if (rowVectors.Count == 0)
+            {
+                throw new ArgumentOutOfRangeException("rowVectors");
+            }
+
+            var rows = rowVectors.Count;
+            var columns = rowVectors[0].Count;
+
+            for (var row = 1; row < rows; row++)
+            {
+                columns = Math.Max(columns, rowVectors[row].Count);
+            }
+
+            var matrix = rowVectors[0].CreateMatrix(rows, columns);
+            for (var i = 0; i < rows; i++)
+            {
+                for (var j = 0; j < rowVectors[i].Count; j++)
+                {
+                    matrix.At(i, j, rowVectors[i][j]);
+                }
+            }
+
+            return matrix;
+        }
+
         /// <summary>
         /// Gets or sets the value at the given row and column.
         /// </summary>
@@ -473,7 +549,7 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
 
             for (var row = 0; row < RowCount; row++)
             {
-                for (var column = 0; column <= row && column < ColumnCount; column++) 
+                for (var column = 0; column <= row && column < ColumnCount; column++)
                 {
                     ret.At(row, column, At(row, column));
                 }
@@ -733,7 +809,7 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
             {
                 diagonal[i] = At(i, i);
             }
-            
+
             return diagonal;
         }
 
@@ -1426,6 +1502,7 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
 
             return BitConverter.ToInt32(BitConverter.GetBytes(hash), 4);
         }
+
         #endregion
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs

@@ -1990,5 +1990,71 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
                 }
             }
         }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of column vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromColumns()
+        {
+            var column1 = CreateVector(new Complex[] { 1.0 });
+            var column2 = CreateVector(new Complex[] { 1.0, 2.0, 3.0, 4.0 });
+            var column3 = CreateVector(new Complex[] { 1.0, 2.0 });
+            var columnVectors = new System.Collections.Generic.List<Vector<Complex>>
+                                {
+                                    column1,
+                                    column2,
+                                    column3
+                                };
+            var matrix = Matrix<Complex>.CreateFromColumns(columnVectors);
+
+            Assert.AreEqual(matrix.RowCount, 4);
+            Assert.AreEqual(matrix.ColumnCount, 3);
+            Assert.AreEqual(1.0, matrix[0, 0].Real);
+            Assert.AreEqual(0.0, matrix[1, 0].Real);
+            Assert.AreEqual(0.0, matrix[2, 0].Real);
+            Assert.AreEqual(0.0, matrix[3, 0].Real);
+            Assert.AreEqual(1.0, matrix[0, 1].Real);
+            Assert.AreEqual(2.0, matrix[1, 1].Real);
+            Assert.AreEqual(3.0, matrix[2, 1].Real);
+            Assert.AreEqual(4.0, matrix[3, 1].Real);
+            Assert.AreEqual(1.0, matrix[0, 2].Real);
+            Assert.AreEqual(2.0, matrix[1, 2].Real);
+            Assert.AreEqual(0.0, matrix[2, 2].Real);
+            Assert.AreEqual(0.0, matrix[3, 2].Real);
+        }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of row vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromRows()
+        {
+            var row1 = CreateVector(new Complex[] { 1.0 });
+            var row2 = CreateVector(new Complex[] { 1.0, 2.0, 3.0, 4.0 });
+            var row3 = CreateVector(new Complex[] { 1.0, 2.0 });
+            var rowVectors = new System.Collections.Generic.List<Vector<Complex>>
+                                {
+                                    row1,
+                                    row2,
+                                    row3
+                                };
+            var matrix = Matrix<Complex>.CreateFromRows(rowVectors);
+
+            Assert.AreEqual(matrix.RowCount, 3);
+            Assert.AreEqual(matrix.ColumnCount, 4);
+            Assert.AreEqual(1.0, matrix[0, 0].Real);
+            Assert.AreEqual(0.0, matrix[0, 1].Real);
+            Assert.AreEqual(0.0, matrix[0, 2].Real);
+            Assert.AreEqual(0.0, matrix[0, 3].Real);
+            Assert.AreEqual(1.0, matrix[1, 0].Real);
+            Assert.AreEqual(2.0, matrix[1, 1].Real);
+            Assert.AreEqual(3.0, matrix[1, 2].Real);
+            Assert.AreEqual(4.0, matrix[1, 3].Real);
+            Assert.AreEqual(1.0, matrix[2, 0].Real);
+            Assert.AreEqual(2.0, matrix[2, 1].Real);
+            Assert.AreEqual(0.0, matrix[2, 2].Real);
+            Assert.AreEqual(0.0, matrix[2, 3].Real);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs

@@ -1990,5 +1990,71 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
                 }
             }
         }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of column vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromColumns()
+        {
+            var column1 = CreateVector(new Complex32[] { 1.0f });
+            var column2 = CreateVector(new Complex32[] { 1.0f, 2.0f, 3.0f, 4.0f });
+            var column3 = CreateVector(new Complex32[] { 1.0f, 2.0f });
+            var columnVectors = new System.Collections.Generic.List<Vector<Complex32>>
+                                {
+                                    column1,
+                                    column2,
+                                    column3
+                                };
+            var matrix = Matrix<Complex32>.CreateFromColumns(columnVectors);
+
+            Assert.AreEqual(matrix.RowCount, 4);
+            Assert.AreEqual(matrix.ColumnCount, 3);
+            Assert.AreEqual(1.0, matrix[0, 0].Real);
+            Assert.AreEqual(0.0, matrix[1, 0].Real);
+            Assert.AreEqual(0.0, matrix[2, 0].Real);
+            Assert.AreEqual(0.0, matrix[3, 0].Real);
+            Assert.AreEqual(1.0, matrix[0, 1].Real);
+            Assert.AreEqual(2.0, matrix[1, 1].Real);
+            Assert.AreEqual(3.0, matrix[2, 1].Real);
+            Assert.AreEqual(4.0, matrix[3, 1].Real);
+            Assert.AreEqual(1.0, matrix[0, 2].Real);
+            Assert.AreEqual(2.0, matrix[1, 2].Real);
+            Assert.AreEqual(0.0, matrix[2, 2].Real);
+            Assert.AreEqual(0.0, matrix[3, 2].Real);
+        }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of row vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromRows()
+        {
+            var row1 = CreateVector(new Complex32[] { 1.0f });
+            var row2 = CreateVector(new Complex32[] { 1.0f, 2.0f, 3.0f, 4.0f });
+            var row3 = CreateVector(new Complex32[] { 1.0f, 2.0f });
+            var rowVectors = new System.Collections.Generic.List<Vector<Complex32>>
+                                {
+                                    row1,
+                                    row2,
+                                    row3
+                                };
+            var matrix = Matrix<Complex32>.CreateFromRows(rowVectors);
+
+            Assert.AreEqual(matrix.RowCount, 3);
+            Assert.AreEqual(matrix.ColumnCount, 4);
+            Assert.AreEqual(1.0, matrix[0, 0].Real);
+            Assert.AreEqual(0.0, matrix[0, 1].Real);
+            Assert.AreEqual(0.0, matrix[0, 2].Real);
+            Assert.AreEqual(0.0, matrix[0, 3].Real);
+            Assert.AreEqual(1.0, matrix[1, 0].Real);
+            Assert.AreEqual(2.0, matrix[1, 1].Real);
+            Assert.AreEqual(3.0, matrix[1, 2].Real);
+            Assert.AreEqual(4.0, matrix[1, 3].Real);
+            Assert.AreEqual(1.0, matrix[2, 0].Real);
+            Assert.AreEqual(2.0, matrix[2, 1].Real);
+            Assert.AreEqual(0.0, matrix[2, 2].Real);
+            Assert.AreEqual(0.0, matrix[2, 3].Real);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs

@@ -1,4 +1,4 @@
-// <copyright file="DenseMatrixTests.cs" company="Math.NET">
+//// <copyright file="DenseMatrixTests.cs" company="Math.NET">
 // Math.NET Numerics, part of the Math.NET Project
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics

src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs

@@ -1927,5 +1927,71 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                 }
             }
         }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of column vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromColumns()
+        {
+            var column1 = CreateVector(new[] { 1.0 });
+            var column2 = CreateVector(new[] { 1.0, 2.0, 3.0, 4.0 });
+            var column3 = CreateVector(new[] { 1.0, 2.0 });
+            var columnVectors = new System.Collections.Generic.List<Vector<double>>
+                                {
+                                    column1,
+                                    column2,
+                                    column3
+                                };
+            var matrix = Matrix<double>.CreateFromColumns(columnVectors);
+
+            Assert.AreEqual(matrix.RowCount, 4);
+            Assert.AreEqual(matrix.ColumnCount, 3);
+            Assert.AreEqual(1.0, matrix[0, 0]);
+            Assert.AreEqual(0.0, matrix[1, 0]);
+            Assert.AreEqual(0.0, matrix[2, 0]);
+            Assert.AreEqual(0.0, matrix[3, 0]);
+            Assert.AreEqual(1.0, matrix[0, 1]);
+            Assert.AreEqual(2.0, matrix[1, 1]);
+            Assert.AreEqual(3.0, matrix[2, 1]);
+            Assert.AreEqual(4.0, matrix[3, 1]);
+            Assert.AreEqual(1.0, matrix[0, 2]);
+            Assert.AreEqual(2.0, matrix[1, 2]);
+            Assert.AreEqual(0.0, matrix[2, 2]);
+            Assert.AreEqual(0.0, matrix[3, 2]);
+        }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of row vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromRows()
+        {
+            var row1 = CreateVector(new[] { 1.0 });
+            var row2 = CreateVector(new[] { 1.0, 2.0, 3.0, 4.0 });
+            var row3 = CreateVector(new[] { 1.0, 2.0 });
+            var rowVectors = new System.Collections.Generic.List<Vector<double>>
+                                {
+                                    row1,
+                                    row2,
+                                    row3
+                                };
+            var matrix = Matrix<double>.CreateFromRows(rowVectors);
+
+            Assert.AreEqual(matrix.RowCount, 3);
+            Assert.AreEqual(matrix.ColumnCount, 4);
+            Assert.AreEqual(1.0, matrix[0, 0]);
+            Assert.AreEqual(0.0, matrix[0, 1]);
+            Assert.AreEqual(0.0, matrix[0, 2]);
+            Assert.AreEqual(0.0, matrix[0, 3]);
+            Assert.AreEqual(1.0, matrix[1, 0]);
+            Assert.AreEqual(2.0, matrix[1, 1]);
+            Assert.AreEqual(3.0, matrix[1, 2]);
+            Assert.AreEqual(4.0, matrix[1, 3]);
+            Assert.AreEqual(1.0, matrix[2, 0]);
+            Assert.AreEqual(2.0, matrix[2, 1]);
+            Assert.AreEqual(0.0, matrix[2, 2]);
+            Assert.AreEqual(0.0, matrix[2, 3]);
+        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs

@@ -1927,5 +1927,71 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
                 }
             }
         }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of column vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromColumns()
+        {
+            var column1 = CreateVector(new[] { 1.0f });
+            var column2 = CreateVector(new[] { 1.0f, 2.0f, 3.0f, 4.0f });
+            var column3 = CreateVector(new[] { 1.0f, 2.0f });
+            var columnVectors = new System.Collections.Generic.List<Vector<float>>
+                                {
+                                    column1,
+                                    column2,
+                                    column3
+                                };
+            var matrix = Matrix<float>.CreateFromColumns(columnVectors);
+
+            Assert.AreEqual(matrix.RowCount, 4);
+            Assert.AreEqual(matrix.ColumnCount, 3);
+            Assert.AreEqual(1.0, matrix[0, 0]);
+            Assert.AreEqual(0.0, matrix[1, 0]);
+            Assert.AreEqual(0.0, matrix[2, 0]);
+            Assert.AreEqual(0.0, matrix[3, 0]);
+            Assert.AreEqual(1.0, matrix[0, 1]);
+            Assert.AreEqual(2.0, matrix[1, 1]);
+            Assert.AreEqual(3.0, matrix[2, 1]);
+            Assert.AreEqual(4.0, matrix[3, 1]);
+            Assert.AreEqual(1.0, matrix[0, 2]);
+            Assert.AreEqual(2.0, matrix[1, 2]);
+            Assert.AreEqual(0.0, matrix[2, 2]);
+            Assert.AreEqual(0.0, matrix[3, 2]);
+        }
+
+        /// <summary>
+        /// Test whether we can create a matrix from a list of row vectors.
+        /// </summary>
+        [Test]
+        public virtual void CanCreateMatrixFromRows()
+        {
+            var row1 = CreateVector(new[] { 1.0f });
+            var row2 = CreateVector(new[] { 1.0f, 2.0f, 3.0f, 4.0f });
+            var row3 = CreateVector(new[] { 1.0f, 2.0f });
+            var rowVectors = new System.Collections.Generic.List<Vector<float>>
+                                {
+                                    row1,
+                                    row2,
+                                    row3
+                                };
+            var matrix = Matrix<float>.CreateFromRows(rowVectors);
+
+            Assert.AreEqual(matrix.RowCount, 3);
+            Assert.AreEqual(matrix.ColumnCount, 4);
+            Assert.AreEqual(1.0, matrix[0, 0]);
+            Assert.AreEqual(0.0, matrix[0, 1]);
+            Assert.AreEqual(0.0, matrix[0, 2]);
+            Assert.AreEqual(0.0, matrix[0, 3]);
+            Assert.AreEqual(1.0, matrix[1, 0]);
+            Assert.AreEqual(2.0, matrix[1, 1]);
+            Assert.AreEqual(3.0, matrix[1, 2]);
+            Assert.AreEqual(4.0, matrix[1, 3]);
+            Assert.AreEqual(1.0, matrix[2, 0]);
+            Assert.AreEqual(2.0, matrix[2, 1]);
+            Assert.AreEqual(0.0, matrix[2, 2]);
+            Assert.AreEqual(0.0, matrix[2, 3]);
+        }
     }
 }