<NME> DenseMatrix.cs
<BEF> ﻿// <copyright file="DenseMatrix.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-2013 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 System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using MathNet.Numerics.Distributions;
using MathNet.Numerics.LinearAlgebra.Double.Factorization;
using MathNet.Numerics.LinearAlgebra.Factorization;
using MathNet.Numerics.LinearAlgebra.Storage;
using MathNet.Numerics.Providers.LinearAlgebra;
using MathNet.Numerics.Threading;

namespace MathNet.Numerics.LinearAlgebra.Double
{
    /// <summary>
    /// A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column).
    /// </summary>
    [Serializable]
    [DebuggerDisplay("DenseMatrix {RowCount}x{ColumnCount}-Double")]
    public class DenseMatrix : Matrix
    {
        /// <summary>
        /// Number of rows.
        /// </summary>
        /// <remarks>Using this instead of the RowCount property to speed up calculating
        /// a matrix index in the data array.</remarks>
        readonly int _rowCount;

        /// <summary>
        /// Number of columns.
        /// </summary>
        /// <remarks>Using this instead of the ColumnCount property to speed up calculating
        /// a matrix index in the data array.</remarks>
        readonly int _columnCount;

        /// <summary>
        /// Gets the matrix's data.
        /// </summary>
        /// <value>The matrix's data.</value>
        readonly double[] _values;

        /// <summary>
        /// Create a new dense matrix straight from an initialized matrix storage instance.
        /// The storage is used directly without copying.
        /// Intended for advanced scenarios where you're working directly with
        /// storage for performance or interop reasons.
        /// </summary>
        public DenseMatrix(DenseColumnMajorMatrixStorage<double> storage)
            : base(storage)
        {
            _rowCount = storage.RowCount;
            _columnCount = storage.ColumnCount;
            _values = storage.Data;
        }

        /// <summary>
        /// Create a new square dense matrix with the given number of rows and columns.
        /// All cells of the matrix will be initialized to zero.
        /// </summary>
        /// <exception cref="ArgumentException">If the order is less than one.</exception>
        public DenseMatrix(int order)
            : this(new DenseColumnMajorMatrixStorage<double>(order, order))
        {
        }

        /// <summary>
        /// Create a new dense matrix with the given number of rows and columns.
        /// All cells of the matrix will be initialized to zero.
        /// </summary>
        /// <exception cref="ArgumentException">If the row or column count is less than one.</exception>
        public DenseMatrix(int rows, int columns)
            : this(new DenseColumnMajorMatrixStorage<double>(rows, columns))
        {
        }

        /// <summary>
        /// Create a new dense matrix with the given number of rows and columns directly binding to a raw array.
        /// The array is assumed to be in column-major order (column by column) and is used directly without copying.
        /// Very efficient, but changes to the array and the matrix will affect each other.
        /// </summary>
        /// <seealso href="http://en.wikipedia.org/wiki/Row-major_order"/>
        public DenseMatrix(int rows, int columns, double[] storage)
            : this(new DenseColumnMajorMatrixStorage<double>(rows, columns, storage))
        {
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given other matrix.
        /// This new matrix will be independent from the other matrix.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfMatrix(Matrix<double> matrix)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfMatrix(matrix.Storage));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given two-dimensional array.
        /// This new matrix will be independent from the provided array.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfArray(double[,] array)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfArray(array));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given indexed enumerable.
        /// Keys must be provided at most once, zero is assumed if a key is omitted.
        /// This new matrix will be independent from the enumerable.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<Tuple<int, int, double>> enumerable)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfIndexedEnumerable(rows, columns, enumerable));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given indexed enumerable.
        /// Keys must be provided at most once, zero is assumed if a key is omitted.
        /// This new matrix will be independent from the enumerable.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<(int, int, double)> enumerable)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfIndexedEnumerable(rows, columns, enumerable));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given enumerable.
        /// The enumerable is assumed to be in column-major order (column by column).
        /// This new matrix will be independent from the enumerable.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumnMajor(int rows, int columns, IEnumerable<double> columnMajor)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnMajorEnumerable(rows, columns, columnMajor));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given enumerable of enumerable columns.
        /// Each enumerable in the master enumerable specifies a column.
        /// This new matrix will be independent from the enumerables.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumns(IEnumerable<IEnumerable<double>> data)
        {
            return OfColumnArrays(data.Select(v => v.ToArray()).ToArray());
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given enumerable of enumerable columns.
        /// Each enumerable in the master enumerable specifies a column.
        /// This new matrix will be independent from the enumerables.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumns(int rows, int columns, IEnumerable<IEnumerable<double>> data)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnEnumerables(rows, columns, data));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given column arrays.
        /// This new matrix will be independent from the arrays.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumnArrays(params double[][] columns)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnArrays(columns));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given column arrays.
        /// This new matrix will be independent from the arrays.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumnArrays(IEnumerable<double[]> columns)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnArrays((columns as double[][]) ?? columns.ToArray()));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given column vectors.
        /// This new matrix will be independent from the vectors.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumnVectors(params Vector<double>[] columns)
        {
            var storage = new VectorStorage<double>[columns.Length];
            for (int i = 0; i < columns.Length; i++)
            {
                storage[i] = columns[i].Storage;
            }
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnVectors(storage));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given column vectors.
        /// This new matrix will be independent from the vectors.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfColumnVectors(IEnumerable<Vector<double>> columns)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnVectors(columns.Select(c => c.Storage).ToArray()));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given enumerable of enumerable rows.
        /// Each enumerable in the master enumerable specifies a row.
        /// This new matrix will be independent from the enumerables.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRows(IEnumerable<IEnumerable<double>> data)
        {
            return OfRowArrays(data.Select(v => v.ToArray()).ToArray());
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given enumerable of enumerable rows.
        /// Each enumerable in the master enumerable specifies a row.
        /// This new matrix will be independent from the enumerables.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRows(int rows, int columns, IEnumerable<IEnumerable<double>> data)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowEnumerables(rows, columns, data));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given row arrays.
        /// This new matrix will be independent from the arrays.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRowArrays(params double[][] rows)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowArrays(rows));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given row arrays.
        /// This new matrix will be independent from the arrays.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRowArrays(IEnumerable<double[]> rows)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowArrays((rows as double[][]) ?? rows.ToArray()));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given row vectors.
        /// This new matrix will be independent from the vectors.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRowVectors(params Vector<double>[] rows)
        {
            var storage = new VectorStorage<double>[rows.Length];
            for (int i = 0; i < rows.Length; i++)
            {
                storage[i] = rows[i].Storage;
            }
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowVectors(storage));
        }

        /// <summary>
        /// Create a new dense matrix as a copy of the given row vectors.
        /// This new matrix will be independent from the vectors.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfRowVectors(IEnumerable<Vector<double>> rows)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowVectors(rows.Select(r => r.Storage).ToArray()));
        }

        /// <summary>
        /// Create a new dense matrix with the diagonal as a copy of the given vector.
        /// This new matrix will be independent from the vector.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfDiagonalVector(Vector<double> diagonal)
        {
            var m = new DenseMatrix(diagonal.Count, diagonal.Count);
            m.SetDiagonal(diagonal);
            return m;
        }

        /// <summary>
        /// Create a new dense matrix with the diagonal as a copy of the given vector.
        /// This new matrix will be independent from the vector.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfDiagonalVector(int rows, int columns, Vector<double> diagonal)
        {
            var m = new DenseMatrix(rows, columns);
            m.SetDiagonal(diagonal);
            return m;
        }

        /// <summary>
        /// Create a new dense matrix with the diagonal as a copy of the given array.
        /// This new matrix will be independent from the array.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfDiagonalArray(double[] diagonal)
        {
            var m = new DenseMatrix(diagonal.Length, diagonal.Length);
            m.SetDiagonal(diagonal);
            return m;
        }

        /// <summary>
        /// Create a new dense matrix with the diagonal as a copy of the given array.
        /// This new matrix will be independent from the array.
        /// A new memory block will be allocated for storing the matrix.
        /// </summary>
        public static DenseMatrix OfDiagonalArray(int rows, int columns, double[] diagonal)
        {
            var m = new DenseMatrix(rows, columns);
            m.SetDiagonal(diagonal);
            return m;
        }

        /// <summary>
        /// Create a new dense matrix and initialize each value to the same provided value.
        /// </summary>
        public static DenseMatrix Create(int rows, int columns, double value)
        {
            if (value == 0d) return new DenseMatrix(rows, columns);
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfValue(rows, columns, value));
        }

        /// <summary>
        /// Create a new dense matrix and initialize each value using the provided init function.
        /// </summary>
        public static DenseMatrix Create(int rows, int columns, Func<int, int, double> init)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns, init));
        }

        /// <summary>
        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.
        /// </summary>
        public static DenseMatrix CreateDiagonal(int rows, int columns, double value)
        {
            if (value == 0d) return new DenseMatrix(rows, columns);
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, _ => value));
        }

        /// <summary>
        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.
        /// </summary>
        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, double> init)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, init));
        }

        /// <summary>
        /// Create a new square sparse identity matrix where each diagonal value is set to One.
        /// </summary>
        public static DenseMatrix CreateIdentity(int order)
        {
            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(order, order, _ => One));
        }

        /// <summary>
        /// Create a new dense matrix with values sampled from the provided random distribution.
        /// </summary>
        public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution)
        {
        }

        #endregion
    }
}
        /// <returns>The square root of the sum of the squared values.</returns>
        public override double FrobeniusNorm()
        {
            return LinearAlgebraControl.Provider.MatrixNorm(Norm.FrobeniusNorm, _rowCount, _columnCount, _values);
        }

        /// <summary>
        /// Negate each element of this matrix and place the results into the result matrix.
        /// </summary>
        /// <param name="result">The result of the negation.</param>
        protected override void DoNegate(Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.ScaleArray(-1, _values, denseResult._values);
                return;
            }

            base.DoNegate(result);
        }

        /// <summary>
        /// Add a scalar to each element of the matrix and stores the result in the result vector.
        /// </summary>
        /// <param name="scalar">The scalar to add.</param>
        /// <param name="result">The matrix to store the result of the addition.</param>
        protected override void DoAdd(double scalar, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                CommonParallel.For(0, _values.Length, 4096, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] = _values[i] + scalar;
                    }
                });
            }
            else
            {
                base.DoAdd(scalar, result);
            }
        }

        /// <summary>
        /// Adds another matrix to this matrix.
        /// </summary>
        /// <param name="other">The matrix to add to this matrix.</param>
        /// <param name="result">The matrix to store the result of add</param>
        /// <exception cref="ArgumentNullException">If the other matrix is <see langword="null"/>.</exception>
        /// <exception cref="ArgumentOutOfRangeException">If the two matrices don't have the same dimensions.</exception>
        protected override void DoAdd(Matrix<double> other, Matrix<double> result)
        {
            // dense + dense = dense
            if (other.Storage is DenseColumnMajorMatrixStorage<double> denseOther && result.Storage is DenseColumnMajorMatrixStorage<double> denseResult)
            {
                LinearAlgebraControl.Provider.AddArrays(_values, denseOther.Data, denseResult.Data);
                return;
            }

            // dense + diagonal = any
            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)
            {
                Storage.CopyToUnchecked(result.Storage, ExistingData.Clear);
                var diagonal = diagonalOther.Data;
                for (int i = 0; i < diagonal.Length; i++)
                {
                    result.At(i, i, result.At(i, i) + diagonal[i]);
                }
                return;
            }

            base.DoAdd(other, result);
        }

        /// <summary>
        /// Subtracts a scalar from each element of the matrix and stores the result in the result vector.
        /// </summary>
        /// <param name="scalar">The scalar to subtract.</param>
        /// <param name="result">The matrix to store the result of the subtraction.</param>
        protected override void DoSubtract(double scalar, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                CommonParallel.For(0, _values.Length, 4096, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] = _values[i] - scalar;
                    }
                });
            }
            else
            {
                base.DoSubtract(scalar, result);
            }
        }

        /// <summary>
        /// Subtracts another matrix from this matrix.
        /// </summary>
        /// <param name="other">The matrix to subtract.</param>
        /// <param name="result">The matrix to store the result of the subtraction.</param>
        protected override void DoSubtract(Matrix<double> other, Matrix<double> result)
        {
            // dense + dense = dense
            if (other.Storage is DenseColumnMajorMatrixStorage<double> denseOther && result.Storage is DenseColumnMajorMatrixStorage<double> denseResult)
            {
                LinearAlgebraControl.Provider.SubtractArrays(_values, denseOther.Data, denseResult.Data);
                return;
            }

            // dense + diagonal = matrix
            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)
            {
                CopyTo(result);
                var diagonal = diagonalOther.Data;
                for (int i = 0; i < diagonal.Length; i++)
                {
                    result.At(i, i, result.At(i, i) - diagonal[i]);
                }
                return;
            }

            base.DoSubtract(other, result);
        }

        /// <summary>
        /// Multiplies each element of the matrix by a scalar and places results into the result matrix.
        /// </summary>
        /// <param name="scalar">The scalar to multiply the matrix with.</param>
        /// <param name="result">The matrix to store the result of the multiplication.</param>
        protected override void DoMultiply(double scalar, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.ScaleArray(scalar, _values, denseResult._values);
            }
            else
            {
                base.DoMultiply(scalar, result);
            }
        }

        /// <summary>
        /// Multiplies this matrix with a vector and places the results into the result vector.
        /// </summary>
        /// <param name="rightSide">The vector to multiply with.</param>
        /// <param name="result">The result of the multiplication.</param>
        protected override void DoMultiply(Vector<double> rightSide, Vector<double> result)
        {
            if (rightSide is DenseVector denseRight && result is DenseVector denseResult)
            {
                LinearAlgebraControl.Provider.MatrixMultiply(
                    _values,
                    _rowCount,
                    _columnCount,
                    denseRight.Values,
                    denseRight.Count,
                    1,
                    denseResult.Values);
            }
            else
            {
                base.DoMultiply(rightSide, result);
            }
        }

        /// <summary>
        /// Multiplies this matrix with another matrix and places the results into the result matrix.
        /// </summary>
        /// <param name="other">The matrix to multiply with.</param>
        /// <param name="result">The result of the multiplication.</param>
        protected override void DoMultiply(Matrix<double> other, Matrix<double> result)
        {
            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.MatrixMultiply(
                    _values,
                    _rowCount,
                    _columnCount,
                    denseOther._values,
                    denseOther._rowCount,
                    denseOther._columnCount,
                    denseResult._values);
                return;
            }

            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)
            {
                var diagonal = diagonalOther.Data;
                var d = Math.Min(ColumnCount, other.ColumnCount);
                if (d < other.ColumnCount)
                {
                    result.ClearSubMatrix(0, RowCount, ColumnCount, other.ColumnCount - ColumnCount);
                }
                int index = 0;
                for (int j = 0; j < d; j++)
                {
                    for (int i = 0; i < RowCount; i++)
                    {
                        result.At(i, j, _values[index]*diagonal[j]);
                        index++;
                    }
                }
                return;
            }

            base.DoMultiply(other, result);
        }

        /// <summary>
        /// Multiplies this matrix with transpose of another matrix and places the results into the result matrix.
        /// </summary>
        /// <param name="other">The matrix to multiply with.</param>
        /// <param name="result">The result of the multiplication.</param>
        protected override void DoTransposeAndMultiply(Matrix<double> other, Matrix<double> result)
        {
            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(
                    Providers.LinearAlgebra.Transpose.DontTranspose,
                    Providers.LinearAlgebra.Transpose.Transpose,
                    1.0,
                    _values,
                    _rowCount,
                    _columnCount,
                    denseOther._values,
                    denseOther._rowCount,
                    denseOther._columnCount,
                    0.0,
                    denseResult._values);
                return;
            }

            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)
            {
                var diagonal = diagonalOther.Data;
                var d = Math.Min(ColumnCount, other.RowCount);
                if (d < other.RowCount)
                {
                    result.ClearSubMatrix(0, RowCount, ColumnCount, other.RowCount - ColumnCount);
                }
                int index = 0;
                for (int j = 0; j < d; j++)
                {
                    for (int i = 0; i < RowCount; i++)
                    {
                        result.At(i, j, _values[index]*diagonal[j]);
                        index++;
                    }
                }
                return;
            }

            base.DoTransposeAndMultiply(other, result);
        }

        /// <summary>
        /// Multiplies the transpose of this matrix with a vector and places the results into the result vector.
        /// </summary>
        /// <param name="rightSide">The vector to multiply with.</param>
        /// <param name="result">The result of the multiplication.</param>
        protected override void DoTransposeThisAndMultiply(Vector<double> rightSide, Vector<double> result)
        {
            if (rightSide is DenseVector denseRight && result is DenseVector denseResult)
            {
                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(
                    Providers.LinearAlgebra.Transpose.Transpose,
                    Providers.LinearAlgebra.Transpose.DontTranspose,
                    1.0,
                    _values,
                    _rowCount,
                    _columnCount,
                    denseRight.Values,
                    denseRight.Count,
                    1,
                    0.0,
                    denseResult.Values);
            }
            else
            {
                base.DoTransposeThisAndMultiply(rightSide, result);
            }
        }

        /// <summary>
        /// Multiplies the transpose of this matrix with another matrix and places the results into the result matrix.
        /// </summary>
        /// <param name="other">The matrix to multiply with.</param>
        /// <param name="result">The result of the multiplication.</param>
        protected override void DoTransposeThisAndMultiply(Matrix<double> other, Matrix<double> result)
        {
            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(
                    Providers.LinearAlgebra.Transpose.Transpose,
                    Providers.LinearAlgebra.Transpose.DontTranspose,
                    1.0,
                    _values,
                    _rowCount,
                    _columnCount,
                    denseOther._values,
                    denseOther._rowCount,
                    denseOther._columnCount,
                    0.0,
                    denseResult._values);
                return;
            }

            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)
            {
                var diagonal = diagonalOther.Data;
                var d = Math.Min(RowCount, other.ColumnCount);
                if (d < other.ColumnCount)
                {
                    result.ClearSubMatrix(0, ColumnCount, RowCount, other.ColumnCount - RowCount);
                }
                int index = 0;
                for (int i = 0; i < ColumnCount; i++)
                {
                    for (int j = 0; j < d; j++)
                    {
                        result.At(i, j, _values[index]*diagonal[j]);
                        index++;
                    }
                    index += (RowCount - d);
                }
                return;
            }

            base.DoTransposeThisAndMultiply(other, result);
        }

        /// <summary>
        /// Divides each element of the matrix by a scalar and places results into the result matrix.
        /// </summary>
        /// <param name="divisor">The scalar to divide the matrix with.</param>
        /// <param name="result">The matrix to store the result of the division.</param>
        protected override void DoDivide(double divisor, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.ScaleArray(1.0 / divisor, _values, denseResult._values);
            }
            else
            {
                base.DoDivide(divisor, result);
            }
        }

        /// <summary>
        /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix.
        /// </summary>
        /// <param name="other">The matrix to pointwise multiply with this one.</param>
        /// <param name="result">The matrix to store the result of the pointwise multiplication.</param>
        protected override void DoPointwiseMultiply(Matrix<double> other, Matrix<double> result)
        {
            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.PointWiseMultiplyArrays(_values, denseOther._values, denseResult._values);
            }
            else
            {
                base.DoPointwiseMultiply(other, result);
            }
        }

        /// <summary>
        /// Pointwise divide this matrix by another matrix and stores the result into the result matrix.
        /// </summary>
        /// <param name="divisor">The matrix to pointwise divide this one by.</param>
        /// <param name="result">The matrix to store the result of the pointwise division.</param>
        protected override void DoPointwiseDivide(Matrix<double> divisor, Matrix<double> result)
        {
            if (divisor is DenseMatrix denseDivisor && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.PointWiseDivideArrays(_values, denseDivisor._values, denseResult._values);
            }
            else
            {
                base.DoPointwiseDivide(divisor, result);
            }
        }

        /// <summary>
        /// Pointwise raise this matrix to an exponent and store the result into the result matrix.
        /// </summary>
        /// <param name="exponent">The exponent to raise this matrix values to.</param>
        /// <param name="result">The vector to store the result of the pointwise power.</param>
        protected override void DoPointwisePower(Matrix<double> exponent, Matrix<double> result)
        {
            if (exponent is DenseMatrix denseExponent && result is DenseMatrix denseResult)
            {
                LinearAlgebraControl.Provider.PointWisePowerArrays(_values, denseExponent._values, denseResult._values);
            }
            else
            {
                base.DoPointwisePower(exponent, result);
            }
        }

        /// <summary>
        /// Computes the canonical modulus, where the result has the sign of the divisor,
        /// for the given divisor each element of the matrix.
        /// </summary>
        /// <param name="divisor">The scalar denominator to use.</param>
        /// <param name="result">Matrix to store the results in.</param>
        protected override void DoModulus(double divisor, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                if (!ReferenceEquals(this, result))
                {
                    CopyTo(result);
                }

                CommonParallel.For(0, _values.Length, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] = Euclid.Modulus(v[i], divisor);
                    }
                });
            }
            else
            {
                base.DoModulus(divisor, result);
            }
        }

        /// <summary>
        /// Computes the canonical modulus, where the result has the sign of the divisor,
        /// for the given dividend for each element of the matrix.
        /// </summary>
        /// <param name="dividend">The scalar numerator to use.</param>
        /// <param name="result">A vector to store the results in.</param>
        protected override void DoModulusByThis(double dividend, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                CommonParallel.For(0, _values.Length, 4096, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] = Euclid.Modulus(dividend, _values[i]);
                    }
                });
            }
            else
            {
                base.DoModulusByThis(dividend, result);
            }
        }

        /// <summary>
        /// Computes the remainder (% operator), where the result has the sign of the dividend,
        /// for the given divisor each element of the matrix.
        /// </summary>
        /// <param name="divisor">The scalar denominator to use.</param>
        /// <param name="result">Matrix to store the results in.</param>
        protected override void DoRemainder(double divisor, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                if (!ReferenceEquals(this, result))
                {
                    CopyTo(result);
                }

                CommonParallel.For(0, _values.Length, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] %= divisor;
                    }
                });
            }
            else
            {
                base.DoRemainder(divisor, result);
            }
        }

        /// <summary>
        /// Computes the remainder (% operator), where the result has the sign of the dividend,
        /// for the given dividend for each element of the matrix.
        /// </summary>
        /// <param name="dividend">The scalar numerator to use.</param>
        /// <param name="result">A vector to store the results in.</param>
        protected override void DoRemainderByThis(double dividend, Matrix<double> result)
        {
            if (result is DenseMatrix denseResult)
            {
                CommonParallel.For(0, _values.Length, 4096, (a, b) =>
                {
                    var v = denseResult._values;
                    for (int i = a; i < b; i++)
                    {
                        v[i] = dividend % _values[i];
                    }
                });
            }
            else
            {
                base.DoRemainderByThis(dividend, result);
            }
        }

        /// <summary>
        /// Computes the trace of this matrix.
        /// </summary>
        /// <returns>The trace of this matrix</returns>
        /// <exception cref="ArgumentException">If the matrix is not square</exception>
        public override double Trace()
        {
            if (_rowCount != _columnCount)
            {
                throw new ArgumentException("Matrix must be square.");
            }

            var sum = 0.0;
            for (var i = 0; i < _rowCount; i++)
            {
                sum += _values[(i * _rowCount) + i];
            }

            return sum;
        }

        /// <summary>
        /// Adds two matrices together and returns the results.
        /// </summary>
        /// <remarks>This operator will allocate new memory for the result. It will
        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which
        /// is denser.</remarks>
        /// <param name="leftSide">The left matrix to add.</param>
        /// <param name="rightSide">The right matrix to add.</param>
        /// <returns>The result of the addition.</returns>
        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="leftSide"/> and <paramref name="rightSide"/> don't have the same dimensions.</exception>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator +(DenseMatrix leftSide, DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            if (leftSide._rowCount != rightSide._rowCount || leftSide._columnCount != rightSide._columnCount)
            {
                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);
            }

            return (DenseMatrix)leftSide.Add(rightSide);
        }

        /// <summary>
        /// Returns a <strong>Matrix</strong> containing the same values of <paramref name="rightSide"/>.
        /// </summary>
        /// <param name="rightSide">The matrix to get the values from.</param>
        /// <returns>A matrix containing a the same values as <paramref name="rightSide"/>.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator +(DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            return (DenseMatrix)rightSide.Clone();
        }

        /// <summary>
        /// Subtracts two matrices together and returns the results.
        /// </summary>
        /// <remarks>This operator will allocate new memory for the result. It will
        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which
        /// is denser.</remarks>
        /// <param name="leftSide">The left matrix to subtract.</param>
        /// <param name="rightSide">The right matrix to subtract.</param>
        /// <returns>The result of the addition.</returns>
        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="leftSide"/> and <paramref name="rightSide"/> don't have the same dimensions.</exception>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator -(DenseMatrix leftSide, DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            if (leftSide._rowCount != rightSide._rowCount || leftSide._columnCount != rightSide._columnCount)
            {
                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);
            }

            return (DenseMatrix)leftSide.Subtract(rightSide);
        }

        /// <summary>
        /// Negates each element of the matrix.
        /// </summary>
        /// <param name="rightSide">The matrix to negate.</param>
        /// <returns>A matrix containing the negated values.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator -(DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            return (DenseMatrix)rightSide.Negate();
        }

        /// <summary>
        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.
        /// </summary>
        /// <param name="leftSide">The matrix to multiply.</param>
        /// <param name="rightSide">The constant to multiply the matrix by.</param>
        /// <returns>The result of the multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator *(DenseMatrix leftSide, double rightSide)
        {
            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            return (DenseMatrix)leftSide.Multiply(rightSide);
        }

        /// <summary>
        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.
        /// </summary>
        /// <param name="leftSide">The matrix to multiply.</param>
        /// <param name="rightSide">The constant to multiply the matrix by.</param>
        /// <returns>The result of the multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator *(double leftSide, DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            return (DenseMatrix)rightSide.Multiply(leftSide);
        }

        /// <summary>
        /// Multiplies two matrices.
        /// </summary>
        /// <remarks>This operator will allocate new memory for the result. It will
        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which
        /// is denser.</remarks>
        /// <param name="leftSide">The left matrix to multiply.</param>
        /// <param name="rightSide">The right matrix to multiply.</param>
        /// <returns>The result of multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>
        /// <exception cref="ArgumentException">If the dimensions of <paramref name="leftSide"/> or <paramref name="rightSide"/> don't conform.</exception>
        public static DenseMatrix operator *(DenseMatrix leftSide, DenseMatrix rightSide)
        {
            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            if (leftSide._columnCount != rightSide._rowCount)
            {
                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);
            }

            return (DenseMatrix)leftSide.Multiply(rightSide);
        }

        /// <summary>
        /// Multiplies a <strong>Matrix</strong> and a Vector.
        /// </summary>
        /// <param name="leftSide">The matrix to multiply.</param>
        /// <param name="rightSide">The vector to multiply.</param>
        /// <returns>The result of multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseVector operator *(DenseMatrix leftSide, DenseVector rightSide)
        {
            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            return (DenseVector)leftSide.Multiply(rightSide);
        }

        /// <summary>
        /// Multiplies a Vector and a <strong>Matrix</strong>.
        /// </summary>
        /// <param name="leftSide">The vector to multiply.</param>
        /// <param name="rightSide">The matrix to multiply.</param>
        /// <returns>The result of multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>
        public static DenseVector operator *(DenseVector leftSide, DenseMatrix rightSide)
        {
            if (rightSide == null)
            {
                throw new ArgumentNullException(nameof(rightSide));
            }

            return (DenseVector)rightSide.LeftMultiply(leftSide);
        }

        /// <summary>
        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.
        /// </summary>
        /// <param name="leftSide">The matrix to multiply.</param>
        /// <param name="rightSide">The constant to multiply the matrix by.</param>
        /// <returns>The result of the multiplication.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>
        public static DenseMatrix operator %(DenseMatrix leftSide, double rightSide)
        {
            if (leftSide == null)
            {
                throw new ArgumentNullException(nameof(leftSide));
            }

            return (DenseMatrix)leftSide.Remainder(rightSide);
        }

        /// <summary>
        /// Evaluates whether this matrix is symmetric.
        /// </summary>
        public override bool IsSymmetric()
        {
            if (RowCount != ColumnCount)
            {
                return false;
            }

            for (var j = 0; j < ColumnCount; j++)
            {
                var index = j * RowCount;
                for (var i = j + 1; i < RowCount; i++)
                {
                    if (_values[(i*ColumnCount) + j] != _values[index + i])
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        public override Cholesky<double> Cholesky()
        {
            return DenseCholesky.Create(this);
        }

        public override LU<double> LU()
        {
            return DenseLU.Create(this);
        }

        public override QR<double> QR(QRMethod method = QRMethod.Thin)
        {
            return DenseQR.Create(this, method);
        }

        public override GramSchmidt<double> GramSchmidt()
        {
            return DenseGramSchmidt.Create(this);
        }

        public override Svd<double> Svd(bool computeVectors = true)
        {
            return DenseSvd.Create(this, computeVectors);
        }

        public override Evd<double> Evd(Symmetricity symmetricity = Symmetricity.Unknown)
        {
            return DenseEvd.Create(this, symmetricity);
        }
    }
}

<MSG> Added static initializer for identity matrix.

<DFF> @@ -397,5 +397,24 @@ public override Matrix Multiply(Matrix other)
         }
 
         #endregion
+
+        #region Static constructors for special matrices.
+        /// <summary>
+        /// Initializes a square <see cref="DenseMatrix"/> with all zero's except for ones on the diagonal.
+        /// </summary>
+        /// <param name="order">the size of the square matrix.</param>
+        /// <exception cref="ArgumentException">
+        /// If <paramref name="order"/> is less than one.
+        /// </exception>
+        public static DenseMatrix Identity(int order)
+        {
+            var m = new DenseMatrix(order);
+            for (int i = 0; i < order; i++)
+            {
+                m[i, i] = 1.0;
+            }
+            return m;
+        }
+        #endregion
     }
 }
\ No newline at end of file

{'commit': 'diff --git a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs\nindex a6311433..c66c6506 100644\n--- a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs\n+++ b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs\n@@ -397,5 +397,24 @@ public override Matrix Multiply(Matrix other)\n         }\n \n         #endregion\n+\n+        #region Static constructors for special matrices.\n+        /// <summary>\n+        /// Initializes a square <see cref="DenseMatrix"/> with all zero\'s except for ones on the diagonal.\n+        /// </summary>\n+        /// <param name="order">the size of the square matrix.</param>\n+        /// <exception cref="ArgumentException">\n+        /// If <paramref name="order"/> is less than one.\n+        /// </exception>\n+        public static DenseMatrix Identity(int order)\n+        {\n+            var m = new DenseMatrix(order);\n+            for (int i = 0; i < order; i++)\n+            {\n+                m[i, i] = 1.0;\n+            }\n+            return m;\n+        }\n+        #endregion\n     }\n }\n\\ No newline at end of file\ndiff --git a/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs\nindex 1d282035..2226c3fe 100644\n--- a/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs\n+++ b/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs\n@@ -120,5 +120,34 @@ public void CanCreateMatrixWithUniformValues()\n                 }\n             }\n         }\n+\n+        [Test]\n+        public void CanCreateIdentity()\n+        {\n+            var matrix = DenseMatrix.Identity(5);\n+            for (var i = 0; i < matrix.RowCount; i++)\n+            {\n+                for (var j = 0; j < matrix.ColumnCount; j++)\n+                {\n+                    if (i == j)\n+                    {\n+                        Assert.AreEqual(1.0, matrix[i, j]);\n+                    }\n+                    else\n+                    {\n+                        Assert.AreEqual(0.0, matrix[i, j]);\n+                    }\n+                }\n+            }\n+        }\n+\n+        [Test]\n+        [Row(0)]\n+        [Row(-1)]\n+        [ExpectedArgumentException]\n+        public void IdentityFailsWithZeroOrNegativeOrder(int order)\n+        {\n+            var matrix = DenseMatrix.Identity(order);\n+        }\n     }\n }\n', 'commit_subject': 'Added static initializer for identity matrix.', 'repo_name': 'mathnet/mathnet-numerics', 'committer': {'name': 'Jurgen Van Gael', 'email': 'b1dc3870eb7ecdb2297fa22f34d316097511ce8f@gmail.com', 'time_sec': '1273996177', 'tz_offset': '480', 'date': {'seconds': '1273996177'}}, 'commit_tree': '9de84d664b905c047d04e334a8b7cb401466af56', 'commit_message': 'Added static initializer for identity matrix.\n', 'language_name': 'C#', 'license': 'mit', 'hunks': '@@ -397,5 +397,24 @@ public override Matrix Multiply(Matrix other)\n         }\n \n         #endregion\n+\n+        #region Static constructors for special matrices.\n+        /// <summary>\n+        /// Initializes a square <see cref="DenseMatrix"/> with all zero\'s except for ones on the diagonal.\n+        /// </summary>\n+        /// <param name="order">the size of the square matrix.</param>\n+        /// <exception cref="ArgumentException">\n+        /// If <paramref name="order"/> is less than one.\n+        /// </exception>\n+        public static DenseMatrix Identity(int order)\n+        {\n+            var m = new DenseMatrix(order);\n+            for (int i = 0; i < order; i++)\n+            {\n+                m[i, i] = 1.0;\n+            }\n+            return m;\n+        }\n+        #endregion\n     }\n }\n\\ No newline at end of file\n', 'addition_count': 19, 'deletion_count': 0, 'src_file': 'a/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs', 'tgt_file': 'b/src/Numerics/LinearAlgebra/Double/DenseMatrix.cs', 'file_extension': '.cs', 'before_file': '\ufeff// <copyright file="DenseMatrix.cs" company="Math.NET">\n// Math.NET Numerics, part of the Math.NET Project\n// http://numerics.mathdotnet.com\n// http://github.com/mathnet/mathnet-numerics\n//\n// Copyright (c) 2009-2013 Math.NET\n//\n// Permission is hereby granted, free of charge, to any person\n// obtaining a copy of this software and associated documentation\n// files (the "Software"), to deal in the Software without\n// restriction, including without limitation the rights to use,\n// copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the\n// Software is furnished to do so, subject to the following\n// conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n// OTHER DEALINGS IN THE SOFTWARE.\n// </copyright>\n\nusing System;\nusing System.Collections.Generic;\nusing System.Diagnostics;\nusing System.Linq;\nusing MathNet.Numerics.Distributions;\nusing MathNet.Numerics.LinearAlgebra.Double.Factorization;\nusing MathNet.Numerics.LinearAlgebra.Factorization;\nusing MathNet.Numerics.LinearAlgebra.Storage;\nusing MathNet.Numerics.Providers.LinearAlgebra;\nusing MathNet.Numerics.Threading;\n\nnamespace MathNet.Numerics.LinearAlgebra.Double\n{\n    /// <summary>\n    /// A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order (column by column).\n    /// </summary>\n    [Serializable]\n    [DebuggerDisplay("DenseMatrix {RowCount}x{ColumnCount}-Double")]\n    public class DenseMatrix : Matrix\n    {\n        /// <summary>\n        /// Number of rows.\n        /// </summary>\n        /// <remarks>Using this instead of the RowCount property to speed up calculating\n        /// a matrix index in the data array.</remarks>\n        readonly int _rowCount;\n\n        /// <summary>\n        /// Number of columns.\n        /// </summary>\n        /// <remarks>Using this instead of the ColumnCount property to speed up calculating\n        /// a matrix index in the data array.</remarks>\n        readonly int _columnCount;\n\n        /// <summary>\n        /// Gets the matrix\'s data.\n        /// </summary>\n        /// <value>The matrix\'s data.</value>\n        readonly double[] _values;\n\n        /// <summary>\n        /// Create a new dense matrix straight from an initialized matrix storage instance.\n        /// The storage is used directly without copying.\n        /// Intended for advanced scenarios where you\'re working directly with\n        /// storage for performance or interop reasons.\n        /// </summary>\n        public DenseMatrix(DenseColumnMajorMatrixStorage<double> storage)\n            : base(storage)\n        {\n            _rowCount = storage.RowCount;\n            _columnCount = storage.ColumnCount;\n            _values = storage.Data;\n        }\n\n        /// <summary>\n        /// Create a new square dense matrix with the given number of rows and columns.\n        /// All cells of the matrix will be initialized to zero.\n        /// </summary>\n        /// <exception cref="ArgumentException">If the order is less than one.</exception>\n        public DenseMatrix(int order)\n            : this(new DenseColumnMajorMatrixStorage<double>(order, order))\n        {\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the given number of rows and columns.\n        /// All cells of the matrix will be initialized to zero.\n        /// </summary>\n        /// <exception cref="ArgumentException">If the row or column count is less than one.</exception>\n        public DenseMatrix(int rows, int columns)\n            : this(new DenseColumnMajorMatrixStorage<double>(rows, columns))\n        {\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the given number of rows and columns directly binding to a raw array.\n        /// The array is assumed to be in column-major order (column by column) and is used directly without copying.\n        /// Very efficient, but changes to the array and the matrix will affect each other.\n        /// </summary>\n        /// <seealso href="http://en.wikipedia.org/wiki/Row-major_order"/>\n        public DenseMatrix(int rows, int columns, double[] storage)\n            : this(new DenseColumnMajorMatrixStorage<double>(rows, columns, storage))\n        {\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given other matrix.\n        /// This new matrix will be independent from the other matrix.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfMatrix(Matrix<double> matrix)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfMatrix(matrix.Storage));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given two-dimensional array.\n        /// This new matrix will be independent from the provided array.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfArray(double[,] array)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfArray(array));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given indexed enumerable.\n        /// Keys must be provided at most once, zero is assumed if a key is omitted.\n        /// This new matrix will be independent from the enumerable.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<Tuple<int, int, double>> enumerable)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfIndexedEnumerable(rows, columns, enumerable));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given indexed enumerable.\n        /// Keys must be provided at most once, zero is assumed if a key is omitted.\n        /// This new matrix will be independent from the enumerable.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<(int, int, double)> enumerable)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfIndexedEnumerable(rows, columns, enumerable));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given enumerable.\n        /// The enumerable is assumed to be in column-major order (column by column).\n        /// This new matrix will be independent from the enumerable.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumnMajor(int rows, int columns, IEnumerable<double> columnMajor)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnMajorEnumerable(rows, columns, columnMajor));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given enumerable of enumerable columns.\n        /// Each enumerable in the master enumerable specifies a column.\n        /// This new matrix will be independent from the enumerables.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumns(IEnumerable<IEnumerable<double>> data)\n        {\n            return OfColumnArrays(data.Select(v => v.ToArray()).ToArray());\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given enumerable of enumerable columns.\n        /// Each enumerable in the master enumerable specifies a column.\n        /// This new matrix will be independent from the enumerables.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumns(int rows, int columns, IEnumerable<IEnumerable<double>> data)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnEnumerables(rows, columns, data));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given column arrays.\n        /// This new matrix will be independent from the arrays.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumnArrays(params double[][] columns)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnArrays(columns));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given column arrays.\n        /// This new matrix will be independent from the arrays.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumnArrays(IEnumerable<double[]> columns)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnArrays((columns as double[][]) ?? columns.ToArray()));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given column vectors.\n        /// This new matrix will be independent from the vectors.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumnVectors(params Vector<double>[] columns)\n        {\n            var storage = new VectorStorage<double>[columns.Length];\n            for (int i = 0; i < columns.Length; i++)\n            {\n                storage[i] = columns[i].Storage;\n            }\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnVectors(storage));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given column vectors.\n        /// This new matrix will be independent from the vectors.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfColumnVectors(IEnumerable<Vector<double>> columns)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfColumnVectors(columns.Select(c => c.Storage).ToArray()));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given enumerable of enumerable rows.\n        /// Each enumerable in the master enumerable specifies a row.\n        /// This new matrix will be independent from the enumerables.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRows(IEnumerable<IEnumerable<double>> data)\n        {\n            return OfRowArrays(data.Select(v => v.ToArray()).ToArray());\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given enumerable of enumerable rows.\n        /// Each enumerable in the master enumerable specifies a row.\n        /// This new matrix will be independent from the enumerables.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRows(int rows, int columns, IEnumerable<IEnumerable<double>> data)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowEnumerables(rows, columns, data));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given row arrays.\n        /// This new matrix will be independent from the arrays.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRowArrays(params double[][] rows)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowArrays(rows));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given row arrays.\n        /// This new matrix will be independent from the arrays.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRowArrays(IEnumerable<double[]> rows)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowArrays((rows as double[][]) ?? rows.ToArray()));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given row vectors.\n        /// This new matrix will be independent from the vectors.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRowVectors(params Vector<double>[] rows)\n        {\n            var storage = new VectorStorage<double>[rows.Length];\n            for (int i = 0; i < rows.Length; i++)\n            {\n                storage[i] = rows[i].Storage;\n            }\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowVectors(storage));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix as a copy of the given row vectors.\n        /// This new matrix will be independent from the vectors.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfRowVectors(IEnumerable<Vector<double>> rows)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowVectors(rows.Select(r => r.Storage).ToArray()));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the diagonal as a copy of the given vector.\n        /// This new matrix will be independent from the vector.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfDiagonalVector(Vector<double> diagonal)\n        {\n            var m = new DenseMatrix(diagonal.Count, diagonal.Count);\n            m.SetDiagonal(diagonal);\n            return m;\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the diagonal as a copy of the given vector.\n        /// This new matrix will be independent from the vector.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfDiagonalVector(int rows, int columns, Vector<double> diagonal)\n        {\n            var m = new DenseMatrix(rows, columns);\n            m.SetDiagonal(diagonal);\n            return m;\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the diagonal as a copy of the given array.\n        /// This new matrix will be independent from the array.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfDiagonalArray(double[] diagonal)\n        {\n            var m = new DenseMatrix(diagonal.Length, diagonal.Length);\n            m.SetDiagonal(diagonal);\n            return m;\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with the diagonal as a copy of the given array.\n        /// This new matrix will be independent from the array.\n        /// A new memory block will be allocated for storing the matrix.\n        /// </summary>\n        public static DenseMatrix OfDiagonalArray(int rows, int columns, double[] diagonal)\n        {\n            var m = new DenseMatrix(rows, columns);\n            m.SetDiagonal(diagonal);\n            return m;\n        }\n\n        /// <summary>\n        /// Create a new dense matrix and initialize each value to the same provided value.\n        /// </summary>\n        public static DenseMatrix Create(int rows, int columns, double value)\n        {\n            if (value == 0d) return new DenseMatrix(rows, columns);\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfValue(rows, columns, value));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix and initialize each value using the provided init function.\n        /// </summary>\n        public static DenseMatrix Create(int rows, int columns, Func<int, int, double> init)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns, init));\n        }\n\n        /// <summary>\n        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.\n        /// </summary>\n        public static DenseMatrix CreateDiagonal(int rows, int columns, double value)\n        {\n            if (value == 0d) return new DenseMatrix(rows, columns);\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, _ => value));\n        }\n\n        /// <summary>\n        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.\n        /// </summary>\n        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, double> init)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, init));\n        }\n\n        /// <summary>\n        /// Create a new square sparse identity matrix where each diagonal value is set to One.\n        /// </summary>\n        public static DenseMatrix CreateIdentity(int order)\n        {\n            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(order, order, _ => One));\n        }\n\n        /// <summary>\n        /// Create a new dense matrix with values sampled from the provided random distribution.\n        /// </summary>\n        public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution)\n        {\n        }\n\n        #endregion\n    }\n}\n        /// <returns>The square root of the sum of the squared values.</returns>\n        public override double FrobeniusNorm()\n        {\n            return LinearAlgebraControl.Provider.MatrixNorm(Norm.FrobeniusNorm, _rowCount, _columnCount, _values);\n        }\n\n        /// <summary>\n        /// Negate each element of this matrix and place the results into the result matrix.\n        /// </summary>\n        /// <param name="result">The result of the negation.</param>\n        protected override void DoNegate(Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.ScaleArray(-1, _values, denseResult._values);\n                return;\n            }\n\n            base.DoNegate(result);\n        }\n\n        /// <summary>\n        /// Add a scalar to each element of the matrix and stores the result in the result vector.\n        /// </summary>\n        /// <param name="scalar">The scalar to add.</param>\n        /// <param name="result">The matrix to store the result of the addition.</param>\n        protected override void DoAdd(double scalar, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                CommonParallel.For(0, _values.Length, 4096, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] = _values[i] + scalar;\n                    }\n                });\n            }\n            else\n            {\n                base.DoAdd(scalar, result);\n            }\n        }\n\n        /// <summary>\n        /// Adds another matrix to this matrix.\n        /// </summary>\n        /// <param name="other">The matrix to add to this matrix.</param>\n        /// <param name="result">The matrix to store the result of add</param>\n        /// <exception cref="ArgumentNullException">If the other matrix is <see langword="null"/>.</exception>\n        /// <exception cref="ArgumentOutOfRangeException">If the two matrices don\'t have the same dimensions.</exception>\n        protected override void DoAdd(Matrix<double> other, Matrix<double> result)\n        {\n            // dense + dense = dense\n            if (other.Storage is DenseColumnMajorMatrixStorage<double> denseOther && result.Storage is DenseColumnMajorMatrixStorage<double> denseResult)\n            {\n                LinearAlgebraControl.Provider.AddArrays(_values, denseOther.Data, denseResult.Data);\n                return;\n            }\n\n            // dense + diagonal = any\n            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)\n            {\n                Storage.CopyToUnchecked(result.Storage, ExistingData.Clear);\n                var diagonal = diagonalOther.Data;\n                for (int i = 0; i < diagonal.Length; i++)\n                {\n                    result.At(i, i, result.At(i, i) + diagonal[i]);\n                }\n                return;\n            }\n\n            base.DoAdd(other, result);\n        }\n\n        /// <summary>\n        /// Subtracts a scalar from each element of the matrix and stores the result in the result vector.\n        /// </summary>\n        /// <param name="scalar">The scalar to subtract.</param>\n        /// <param name="result">The matrix to store the result of the subtraction.</param>\n        protected override void DoSubtract(double scalar, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                CommonParallel.For(0, _values.Length, 4096, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] = _values[i] - scalar;\n                    }\n                });\n            }\n            else\n            {\n                base.DoSubtract(scalar, result);\n            }\n        }\n\n        /// <summary>\n        /// Subtracts another matrix from this matrix.\n        /// </summary>\n        /// <param name="other">The matrix to subtract.</param>\n        /// <param name="result">The matrix to store the result of the subtraction.</param>\n        protected override void DoSubtract(Matrix<double> other, Matrix<double> result)\n        {\n            // dense + dense = dense\n            if (other.Storage is DenseColumnMajorMatrixStorage<double> denseOther && result.Storage is DenseColumnMajorMatrixStorage<double> denseResult)\n            {\n                LinearAlgebraControl.Provider.SubtractArrays(_values, denseOther.Data, denseResult.Data);\n                return;\n            }\n\n            // dense + diagonal = matrix\n            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)\n            {\n                CopyTo(result);\n                var diagonal = diagonalOther.Data;\n                for (int i = 0; i < diagonal.Length; i++)\n                {\n                    result.At(i, i, result.At(i, i) - diagonal[i]);\n                }\n                return;\n            }\n\n            base.DoSubtract(other, result);\n        }\n\n        /// <summary>\n        /// Multiplies each element of the matrix by a scalar and places results into the result matrix.\n        /// </summary>\n        /// <param name="scalar">The scalar to multiply the matrix with.</param>\n        /// <param name="result">The matrix to store the result of the multiplication.</param>\n        protected override void DoMultiply(double scalar, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.ScaleArray(scalar, _values, denseResult._values);\n            }\n            else\n            {\n                base.DoMultiply(scalar, result);\n            }\n        }\n\n        /// <summary>\n        /// Multiplies this matrix with a vector and places the results into the result vector.\n        /// </summary>\n        /// <param name="rightSide">The vector to multiply with.</param>\n        /// <param name="result">The result of the multiplication.</param>\n        protected override void DoMultiply(Vector<double> rightSide, Vector<double> result)\n        {\n            if (rightSide is DenseVector denseRight && result is DenseVector denseResult)\n            {\n                LinearAlgebraControl.Provider.MatrixMultiply(\n                    _values,\n                    _rowCount,\n                    _columnCount,\n                    denseRight.Values,\n                    denseRight.Count,\n                    1,\n                    denseResult.Values);\n            }\n            else\n            {\n                base.DoMultiply(rightSide, result);\n            }\n        }\n\n        /// <summary>\n        /// Multiplies this matrix with another matrix and places the results into the result matrix.\n        /// </summary>\n        /// <param name="other">The matrix to multiply with.</param>\n        /// <param name="result">The result of the multiplication.</param>\n        protected override void DoMultiply(Matrix<double> other, Matrix<double> result)\n        {\n            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.MatrixMultiply(\n                    _values,\n                    _rowCount,\n                    _columnCount,\n                    denseOther._values,\n                    denseOther._rowCount,\n                    denseOther._columnCount,\n                    denseResult._values);\n                return;\n            }\n\n            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)\n            {\n                var diagonal = diagonalOther.Data;\n                var d = Math.Min(ColumnCount, other.ColumnCount);\n                if (d < other.ColumnCount)\n                {\n                    result.ClearSubMatrix(0, RowCount, ColumnCount, other.ColumnCount - ColumnCount);\n                }\n                int index = 0;\n                for (int j = 0; j < d; j++)\n                {\n                    for (int i = 0; i < RowCount; i++)\n                    {\n                        result.At(i, j, _values[index]*diagonal[j]);\n                        index++;\n                    }\n                }\n                return;\n            }\n\n            base.DoMultiply(other, result);\n        }\n\n        /// <summary>\n        /// Multiplies this matrix with transpose of another matrix and places the results into the result matrix.\n        /// </summary>\n        /// <param name="other">The matrix to multiply with.</param>\n        /// <param name="result">The result of the multiplication.</param>\n        protected override void DoTransposeAndMultiply(Matrix<double> other, Matrix<double> result)\n        {\n            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(\n                    Providers.LinearAlgebra.Transpose.DontTranspose,\n                    Providers.LinearAlgebra.Transpose.Transpose,\n                    1.0,\n                    _values,\n                    _rowCount,\n                    _columnCount,\n                    denseOther._values,\n                    denseOther._rowCount,\n                    denseOther._columnCount,\n                    0.0,\n                    denseResult._values);\n                return;\n            }\n\n            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)\n            {\n                var diagonal = diagonalOther.Data;\n                var d = Math.Min(ColumnCount, other.RowCount);\n                if (d < other.RowCount)\n                {\n                    result.ClearSubMatrix(0, RowCount, ColumnCount, other.RowCount - ColumnCount);\n                }\n                int index = 0;\n                for (int j = 0; j < d; j++)\n                {\n                    for (int i = 0; i < RowCount; i++)\n                    {\n                        result.At(i, j, _values[index]*diagonal[j]);\n                        index++;\n                    }\n                }\n                return;\n            }\n\n            base.DoTransposeAndMultiply(other, result);\n        }\n\n        /// <summary>\n        /// Multiplies the transpose of this matrix with a vector and places the results into the result vector.\n        /// </summary>\n        /// <param name="rightSide">The vector to multiply with.</param>\n        /// <param name="result">The result of the multiplication.</param>\n        protected override void DoTransposeThisAndMultiply(Vector<double> rightSide, Vector<double> result)\n        {\n            if (rightSide is DenseVector denseRight && result is DenseVector denseResult)\n            {\n                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(\n                    Providers.LinearAlgebra.Transpose.Transpose,\n                    Providers.LinearAlgebra.Transpose.DontTranspose,\n                    1.0,\n                    _values,\n                    _rowCount,\n                    _columnCount,\n                    denseRight.Values,\n                    denseRight.Count,\n                    1,\n                    0.0,\n                    denseResult.Values);\n            }\n            else\n            {\n                base.DoTransposeThisAndMultiply(rightSide, result);\n            }\n        }\n\n        /// <summary>\n        /// Multiplies the transpose of this matrix with another matrix and places the results into the result matrix.\n        /// </summary>\n        /// <param name="other">The matrix to multiply with.</param>\n        /// <param name="result">The result of the multiplication.</param>\n        protected override void DoTransposeThisAndMultiply(Matrix<double> other, Matrix<double> result)\n        {\n            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.MatrixMultiplyWithUpdate(\n                    Providers.LinearAlgebra.Transpose.Transpose,\n                    Providers.LinearAlgebra.Transpose.DontTranspose,\n                    1.0,\n                    _values,\n                    _rowCount,\n                    _columnCount,\n                    denseOther._values,\n                    denseOther._rowCount,\n                    denseOther._columnCount,\n                    0.0,\n                    denseResult._values);\n                return;\n            }\n\n            if (other.Storage is DiagonalMatrixStorage<double> diagonalOther)\n            {\n                var diagonal = diagonalOther.Data;\n                var d = Math.Min(RowCount, other.ColumnCount);\n                if (d < other.ColumnCount)\n                {\n                    result.ClearSubMatrix(0, ColumnCount, RowCount, other.ColumnCount - RowCount);\n                }\n                int index = 0;\n                for (int i = 0; i < ColumnCount; i++)\n                {\n                    for (int j = 0; j < d; j++)\n                    {\n                        result.At(i, j, _values[index]*diagonal[j]);\n                        index++;\n                    }\n                    index += (RowCount - d);\n                }\n                return;\n            }\n\n            base.DoTransposeThisAndMultiply(other, result);\n        }\n\n        /// <summary>\n        /// Divides each element of the matrix by a scalar and places results into the result matrix.\n        /// </summary>\n        /// <param name="divisor">The scalar to divide the matrix with.</param>\n        /// <param name="result">The matrix to store the result of the division.</param>\n        protected override void DoDivide(double divisor, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.ScaleArray(1.0 / divisor, _values, denseResult._values);\n            }\n            else\n            {\n                base.DoDivide(divisor, result);\n            }\n        }\n\n        /// <summary>\n        /// Pointwise multiplies this matrix with another matrix and stores the result into the result matrix.\n        /// </summary>\n        /// <param name="other">The matrix to pointwise multiply with this one.</param>\n        /// <param name="result">The matrix to store the result of the pointwise multiplication.</param>\n        protected override void DoPointwiseMultiply(Matrix<double> other, Matrix<double> result)\n        {\n            if (other is DenseMatrix denseOther && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.PointWiseMultiplyArrays(_values, denseOther._values, denseResult._values);\n            }\n            else\n            {\n                base.DoPointwiseMultiply(other, result);\n            }\n        }\n\n        /// <summary>\n        /// Pointwise divide this matrix by another matrix and stores the result into the result matrix.\n        /// </summary>\n        /// <param name="divisor">The matrix to pointwise divide this one by.</param>\n        /// <param name="result">The matrix to store the result of the pointwise division.</param>\n        protected override void DoPointwiseDivide(Matrix<double> divisor, Matrix<double> result)\n        {\n            if (divisor is DenseMatrix denseDivisor && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.PointWiseDivideArrays(_values, denseDivisor._values, denseResult._values);\n            }\n            else\n            {\n                base.DoPointwiseDivide(divisor, result);\n            }\n        }\n\n        /// <summary>\n        /// Pointwise raise this matrix to an exponent and store the result into the result matrix.\n        /// </summary>\n        /// <param name="exponent">The exponent to raise this matrix values to.</param>\n        /// <param name="result">The vector to store the result of the pointwise power.</param>\n        protected override void DoPointwisePower(Matrix<double> exponent, Matrix<double> result)\n        {\n            if (exponent is DenseMatrix denseExponent && result is DenseMatrix denseResult)\n            {\n                LinearAlgebraControl.Provider.PointWisePowerArrays(_values, denseExponent._values, denseResult._values);\n            }\n            else\n            {\n                base.DoPointwisePower(exponent, result);\n            }\n        }\n\n        /// <summary>\n        /// Computes the canonical modulus, where the result has the sign of the divisor,\n        /// for the given divisor each element of the matrix.\n        /// </summary>\n        /// <param name="divisor">The scalar denominator to use.</param>\n        /// <param name="result">Matrix to store the results in.</param>\n        protected override void DoModulus(double divisor, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                if (!ReferenceEquals(this, result))\n                {\n                    CopyTo(result);\n                }\n\n                CommonParallel.For(0, _values.Length, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] = Euclid.Modulus(v[i], divisor);\n                    }\n                });\n            }\n            else\n            {\n                base.DoModulus(divisor, result);\n            }\n        }\n\n        /// <summary>\n        /// Computes the canonical modulus, where the result has the sign of the divisor,\n        /// for the given dividend for each element of the matrix.\n        /// </summary>\n        /// <param name="dividend">The scalar numerator to use.</param>\n        /// <param name="result">A vector to store the results in.</param>\n        protected override void DoModulusByThis(double dividend, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                CommonParallel.For(0, _values.Length, 4096, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] = Euclid.Modulus(dividend, _values[i]);\n                    }\n                });\n            }\n            else\n            {\n                base.DoModulusByThis(dividend, result);\n            }\n        }\n\n        /// <summary>\n        /// Computes the remainder (% operator), where the result has the sign of the dividend,\n        /// for the given divisor each element of the matrix.\n        /// </summary>\n        /// <param name="divisor">The scalar denominator to use.</param>\n        /// <param name="result">Matrix to store the results in.</param>\n        protected override void DoRemainder(double divisor, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                if (!ReferenceEquals(this, result))\n                {\n                    CopyTo(result);\n                }\n\n                CommonParallel.For(0, _values.Length, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] %= divisor;\n                    }\n                });\n            }\n            else\n            {\n                base.DoRemainder(divisor, result);\n            }\n        }\n\n        /// <summary>\n        /// Computes the remainder (% operator), where the result has the sign of the dividend,\n        /// for the given dividend for each element of the matrix.\n        /// </summary>\n        /// <param name="dividend">The scalar numerator to use.</param>\n        /// <param name="result">A vector to store the results in.</param>\n        protected override void DoRemainderByThis(double dividend, Matrix<double> result)\n        {\n            if (result is DenseMatrix denseResult)\n            {\n                CommonParallel.For(0, _values.Length, 4096, (a, b) =>\n                {\n                    var v = denseResult._values;\n                    for (int i = a; i < b; i++)\n                    {\n                        v[i] = dividend % _values[i];\n                    }\n                });\n            }\n            else\n            {\n                base.DoRemainderByThis(dividend, result);\n            }\n        }\n\n        /// <summary>\n        /// Computes the trace of this matrix.\n        /// </summary>\n        /// <returns>The trace of this matrix</returns>\n        /// <exception cref="ArgumentException">If the matrix is not square</exception>\n        public override double Trace()\n        {\n            if (_rowCount != _columnCount)\n            {\n                throw new ArgumentException("Matrix must be square.");\n            }\n\n            var sum = 0.0;\n            for (var i = 0; i < _rowCount; i++)\n            {\n                sum += _values[(i * _rowCount) + i];\n            }\n\n            return sum;\n        }\n\n        /// <summary>\n        /// Adds two matrices together and returns the results.\n        /// </summary>\n        /// <remarks>This operator will allocate new memory for the result. It will\n        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which\n        /// is denser.</remarks>\n        /// <param name="leftSide">The left matrix to add.</param>\n        /// <param name="rightSide">The right matrix to add.</param>\n        /// <returns>The result of the addition.</returns>\n        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="leftSide"/> and <paramref name="rightSide"/> don\'t have the same dimensions.</exception>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator +(DenseMatrix leftSide, DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            if (leftSide._rowCount != rightSide._rowCount || leftSide._columnCount != rightSide._columnCount)\n            {\n                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);\n            }\n\n            return (DenseMatrix)leftSide.Add(rightSide);\n        }\n\n        /// <summary>\n        /// Returns a <strong>Matrix</strong> containing the same values of <paramref name="rightSide"/>.\n        /// </summary>\n        /// <param name="rightSide">The matrix to get the values from.</param>\n        /// <returns>A matrix containing a the same values as <paramref name="rightSide"/>.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator +(DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            return (DenseMatrix)rightSide.Clone();\n        }\n\n        /// <summary>\n        /// Subtracts two matrices together and returns the results.\n        /// </summary>\n        /// <remarks>This operator will allocate new memory for the result. It will\n        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which\n        /// is denser.</remarks>\n        /// <param name="leftSide">The left matrix to subtract.</param>\n        /// <param name="rightSide">The right matrix to subtract.</param>\n        /// <returns>The result of the addition.</returns>\n        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="leftSide"/> and <paramref name="rightSide"/> don\'t have the same dimensions.</exception>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator -(DenseMatrix leftSide, DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            if (leftSide._rowCount != rightSide._rowCount || leftSide._columnCount != rightSide._columnCount)\n            {\n                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);\n            }\n\n            return (DenseMatrix)leftSide.Subtract(rightSide);\n        }\n\n        /// <summary>\n        /// Negates each element of the matrix.\n        /// </summary>\n        /// <param name="rightSide">The matrix to negate.</param>\n        /// <returns>A matrix containing the negated values.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator -(DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            return (DenseMatrix)rightSide.Negate();\n        }\n\n        /// <summary>\n        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.\n        /// </summary>\n        /// <param name="leftSide">The matrix to multiply.</param>\n        /// <param name="rightSide">The constant to multiply the matrix by.</param>\n        /// <returns>The result of the multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator *(DenseMatrix leftSide, double rightSide)\n        {\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            return (DenseMatrix)leftSide.Multiply(rightSide);\n        }\n\n        /// <summary>\n        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.\n        /// </summary>\n        /// <param name="leftSide">The matrix to multiply.</param>\n        /// <param name="rightSide">The constant to multiply the matrix by.</param>\n        /// <returns>The result of the multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator *(double leftSide, DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            return (DenseMatrix)rightSide.Multiply(leftSide);\n        }\n\n        /// <summary>\n        /// Multiplies two matrices.\n        /// </summary>\n        /// <remarks>This operator will allocate new memory for the result. It will\n        /// choose the representation of either <paramref name="leftSide"/> or <paramref name="rightSide"/> depending on which\n        /// is denser.</remarks>\n        /// <param name="leftSide">The left matrix to multiply.</param>\n        /// <param name="rightSide">The right matrix to multiply.</param>\n        /// <returns>The result of multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        /// <exception cref="ArgumentException">If the dimensions of <paramref name="leftSide"/> or <paramref name="rightSide"/> don\'t conform.</exception>\n        public static DenseMatrix operator *(DenseMatrix leftSide, DenseMatrix rightSide)\n        {\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            if (leftSide._columnCount != rightSide._rowCount)\n            {\n                throw DimensionsDontMatch<ArgumentOutOfRangeException>(leftSide, rightSide);\n            }\n\n            return (DenseMatrix)leftSide.Multiply(rightSide);\n        }\n\n        /// <summary>\n        /// Multiplies a <strong>Matrix</strong> and a Vector.\n        /// </summary>\n        /// <param name="leftSide">The matrix to multiply.</param>\n        /// <param name="rightSide">The vector to multiply.</param>\n        /// <returns>The result of multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseVector operator *(DenseMatrix leftSide, DenseVector rightSide)\n        {\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            return (DenseVector)leftSide.Multiply(rightSide);\n        }\n\n        /// <summary>\n        /// Multiplies a Vector and a <strong>Matrix</strong>.\n        /// </summary>\n        /// <param name="leftSide">The vector to multiply.</param>\n        /// <param name="rightSide">The matrix to multiply.</param>\n        /// <returns>The result of multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> or <paramref name="rightSide"/> is <see langword="null" />.</exception>\n        public static DenseVector operator *(DenseVector leftSide, DenseMatrix rightSide)\n        {\n            if (rightSide == null)\n            {\n                throw new ArgumentNullException(nameof(rightSide));\n            }\n\n            return (DenseVector)rightSide.LeftMultiply(leftSide);\n        }\n\n        /// <summary>\n        /// Multiplies a <strong>Matrix</strong> by a constant and returns the result.\n        /// </summary>\n        /// <param name="leftSide">The matrix to multiply.</param>\n        /// <param name="rightSide">The constant to multiply the matrix by.</param>\n        /// <returns>The result of the multiplication.</returns>\n        /// <exception cref="ArgumentNullException">If <paramref name="leftSide"/> is <see langword="null" />.</exception>\n        public static DenseMatrix operator %(DenseMatrix leftSide, double rightSide)\n        {\n            if (leftSide == null)\n            {\n                throw new ArgumentNullException(nameof(leftSide));\n            }\n\n            return (DenseMatrix)leftSide.Remainder(rightSide);\n        }\n\n        /// <summary>\n        /// Evaluates whether this matrix is symmetric.\n        /// </summary>\n        public override bool IsSymmetric()\n        {\n            if (RowCount != ColumnCount)\n            {\n                return false;\n            }\n\n            for (var j = 0; j < ColumnCount; j++)\n            {\n                var index = j * RowCount;\n                for (var i = j + 1; i < RowCount; i++)\n                {\n                    if (_values[(i*ColumnCount) + j] != _values[index + i])\n                    {\n                        return false;\n                    }\n                }\n            }\n\n            return true;\n        }\n\n        public override Cholesky<double> Cholesky()\n        {\n            return DenseCholesky.Create(this);\n        }\n\n        public override LU<double> LU()\n        {\n            return DenseLU.Create(this);\n        }\n\n        public override QR<double> QR(QRMethod method = QRMethod.Thin)\n        {\n            return DenseQR.Create(this, method);\n        }\n\n        public override GramSchmidt<double> GramSchmidt()\n        {\n            return DenseGramSchmidt.Create(this);\n        }\n\n        public override Svd<double> Svd(bool computeVectors = true)\n        {\n            return DenseSvd.Create(this, computeVectors);\n        }\n\n        public override Evd<double> Evd(Symmetricity symmetricity = Symmetricity.Unknown)\n        {\n            return DenseEvd.Create(this, symmetricity);\n        }\n    }\n}\n', 'message': 'Added static initializer for identity matrix.\n', 'author_name': 'Jurgen Van Gael', 'lang': 'cs'}