added Alex Karatarakis fix for the TransposeAndMultiply bug, work item: 5673

src/Numerics/LinearAlgebra/Complex/Matrix.cs

@@ -264,7 +264,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// <param name="result">The result of the multiplication.</param>
         protected override void DoTransposeAndMultiply(Matrix<Complex> other, Matrix<Complex> result)
         {
-            for (var j = 0; j < RowCount; j++)
+            for (var j = 0; j < other.RowCount; j++)
             {
                 for (var i = 0; i < RowCount; i++)
                 {

src/Numerics/LinearAlgebra/Complex32/Matrix.cs

@@ -264,7 +264,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <param name="result">The result of the multiplication.</param>
         protected override void DoTransposeAndMultiply(Matrix<Complex32> other, Matrix<Complex32> result)
         {
-            for (var j = 0; j < RowCount; j++)
+            for (var j = 0; j < other.RowCount; j++)
             {
                 for (var i = 0; i < RowCount; i++)
                 {

src/Numerics/LinearAlgebra/Double/Matrix.cs

@@ -254,7 +254,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// <param name="result">The result of the multiplication.</param>
         protected override void DoTransposeAndMultiply(Matrix<double> other, Matrix<double> result)
         {
-            for (var j = 0; j < RowCount; j++)
+            for (var j = 0; j < other.RowCount; j++)
             {
                 for (var i = 0; i < RowCount; i++)
                 {

src/Numerics/LinearAlgebra/Single/Matrix.cs

@@ -254,7 +254,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// <param name="result">The result of the multiplication.</param>
         protected override void DoTransposeAndMultiply(Matrix<float> other, Matrix<float> result)
         {
-            for (var j = 0; j < RowCount; j++)
+            for (var j = 0; j < other.RowCount; j++)
             {
                 for (var i = 0; i < RowCount; i++)
                 {

src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.Arithmetic.cs

@@ -545,6 +545,40 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             }
         }
 
+        /// <summary>
+        /// Can transpose and multiply a matrix with differing dimensions.
+        /// </summary>
+        [Test]
+        public void CanTransposeAndMultiplyWithDifferingDimensions()
+        {
+            var matrixA = TestMatrices["Tall3x2"];
+            var matrixB = CreateMatrix(5, 2);
+            var count = 1;
+            for (var row = 0; row < matrixB.RowCount; row++)
+            {
+                for (var col = 0; col < matrixB.ColumnCount; col++)
+                {
+                    if (row == col)
+                    {
+                        matrixB[row, col] = count++;
+                    }
+                }
+            }
+
+            var matrixC = matrixA.TransposeAndMultiply(matrixB);
+
+            Assert.AreEqual(matrixC.RowCount, matrixA.RowCount);
+            Assert.AreEqual(matrixC.ColumnCount, matrixB.RowCount);
+
+            for (var i = 0; i < matrixC.RowCount; i++)
+            {
+                for (var j = 0; j < matrixC.ColumnCount; j++)
+                {
+                    AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15);
+                }
+            }
+        }
+
         /// <summary>
         /// Transpose and multiply a matrix with matrix of incompatible size throws <c>ArgumentException</c>.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.Arithmetic.cs

@@ -545,6 +545,40 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             }
         }
 
+        /// <summary>
+        /// Can transpose and multiply a matrix with differing dimensions.
+        /// </summary>
+        [Test]
+        public void CanTransposeAndMultiplyWithDifferingDimensions()
+        {
+            var matrixA = TestMatrices["Tall3x2"];
+            var matrixB = CreateMatrix(5, 2);
+            var count = 1;
+            for (var row = 0; row < matrixB.RowCount; row++)
+            {
+                for (var col = 0; col < matrixB.ColumnCount; col++)
+                {
+                    if (row == col)
+                    {
+                        matrixB[row, col] = count++;
+                    }
+                }
+            }
+
+            var matrixC = matrixA.TransposeAndMultiply(matrixB);
+
+            Assert.AreEqual(matrixC.RowCount, matrixA.RowCount);
+            Assert.AreEqual(matrixC.ColumnCount, matrixB.RowCount);
+
+            for (var i = 0; i < matrixC.RowCount; i++)
+            {
+                for (var j = 0; j < matrixC.ColumnCount; j++)
+                {
+                    AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15);
+                }
+            }
+        }
+
         /// <summary>
         /// Transpose and multiply a matrix with matrix of incompatible size throws <c>ArgumentException</c>.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs

@@ -540,6 +540,40 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             }
         }
 
+        /// <summary>
+        /// Can transpose and multiply a matrix with differing dimensions.
+        /// </summary>
+        [Test]
+        public void CanTransposeAndMultiplyWithDifferingDimensions()
+        {
+            var matrixA = TestMatrices["Tall3x2"];
+            var matrixB = CreateMatrix(5, 2);
+            var count = 1;
+            for (var row = 0; row < matrixB.RowCount; row++)
+            {
+                for (var col = 0; col < matrixB.ColumnCount; col++)
+                {
+                    if (row == col)
+                    {
+                        matrixB[row, col] = count++;
+                    }
+                }
+            }
+
+            var matrixC = matrixA.TransposeAndMultiply(matrixB);
+
+            Assert.AreEqual(matrixC.RowCount, matrixA.RowCount);
+            Assert.AreEqual(matrixC.ColumnCount, matrixB.RowCount);
+
+            for (var i = 0; i < matrixC.RowCount; i++)
+            {
+                for (var j = 0; j < matrixC.ColumnCount; j++)
+                {
+                    AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15);
+                }
+            }
+        }
+
         /// <summary>
         /// Transpose and multiply a matrix with matrix of incompatible size throws <c>ArgumentException</c>.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Single/MatrixTests.Arithmetic.cs

@@ -540,6 +540,40 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             }
         }
 
+        /// <summary>
+        /// Can transpose and multiply a matrix with differing dimensions.
+        /// </summary>
+        [Test]
+        public void CanTransposeAndMultiplyWithDifferingDimensions()
+        {
+            var matrixA = TestMatrices["Tall3x2"];
+            var matrixB = CreateMatrix(5, 2);
+            var count = 1;
+            for (var row = 0; row < matrixB.RowCount; row++)
+            {
+                for (var col = 0; col < matrixB.ColumnCount; col++)
+                {
+                    if (row == col)
+                    {
+                        matrixB[row, col] = count++;
+                    }
+                }
+            }
+
+            var matrixC = matrixA.TransposeAndMultiply(matrixB);
+
+            Assert.AreEqual(matrixC.RowCount, matrixA.RowCount);
+            Assert.AreEqual(matrixC.ColumnCount, matrixB.RowCount);
+
+            for (var i = 0; i < matrixC.RowCount; i++)
+            {
+                for (var j = 0; j < matrixC.ColumnCount; j++)
+                {
+                    AssertHelpers.AlmostEqual(matrixA.Row(i) * matrixB.Row(j), matrixC[i, j], 15);
+                }
+            }
+        }
+
         /// <summary>
         /// Transpose and multiply a matrix with matrix of incompatible size throws <c>ArgumentException</c>.
         /// </summary>