forked from tsai/mathnet-numerics
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
888 lines
34 KiB
888 lines
34 KiB
// <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
|
|
// http://mathnetnumerics.codeplex.com
|
|
// Copyright (c) 2009-2010 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>
|
|
|
|
namespace MathNet.Numerics.LinearAlgebra.Complex32
|
|
{
|
|
using System;
|
|
using Algorithms.LinearAlgebra;
|
|
using Generic;
|
|
using Numerics;
|
|
using Properties;
|
|
|
|
/// <summary>
|
|
/// A Matrix class with dense storage. The underlying storage is a one dimensional array in column-major order.
|
|
/// </summary>
|
|
[Serializable]
|
|
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>
|
|
private 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>
|
|
private readonly int _columnCount;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DenseMatrix"/> class. This matrix is square with a given size.
|
|
/// </summary>
|
|
/// <param name="order">the size of the square matrix.</param>
|
|
/// <exception cref="ArgumentException">
|
|
/// If <paramref name="order"/> is less than one.
|
|
/// </exception>
|
|
public DenseMatrix(int order)
|
|
: base(order)
|
|
{
|
|
_rowCount = order;
|
|
_columnCount = order;
|
|
Data = new Complex32[order * order];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DenseMatrix"/> class.
|
|
/// </summary>
|
|
/// <param name="rows">
|
|
/// The number of rows.
|
|
/// </param>
|
|
/// <param name="columns">
|
|
/// The number of columns.
|
|
/// </param>
|
|
public DenseMatrix(int rows, int columns)
|
|
: base(rows, columns)
|
|
{
|
|
_rowCount = rows;
|
|
_columnCount = columns;
|
|
Data = new Complex32[rows * columns];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DenseMatrix"/> class with all entries set to a particular value.
|
|
/// </summary>
|
|
/// <param name="rows">
|
|
/// The number of rows.
|
|
/// </param>
|
|
/// <param name="columns">
|
|
/// The number of columns.
|
|
/// </param>
|
|
/// <param name="value">The value which we assign to each element of the matrix.</param>
|
|
public DenseMatrix(int rows, int columns, Complex32 value)
|
|
: base(rows, columns)
|
|
{
|
|
_rowCount = rows;
|
|
_columnCount = columns;
|
|
Data = new Complex32[rows * columns];
|
|
for (var i = 0; i < Data.Length; i++)
|
|
{
|
|
Data[i] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DenseMatrix"/> class from a one dimensional array. This constructor
|
|
/// will reference the one dimensional array and not copy it.
|
|
/// </summary>
|
|
/// <param name="rows">The number of rows.</param>
|
|
/// <param name="columns">The number of columns.</param>
|
|
/// <param name="array">The one dimensional array to create this matrix from. This array should store the matrix in column-major order. see: http://en.wikipedia.org/wiki/Row-major_order </param>
|
|
public DenseMatrix(int rows, int columns, Complex32[] array)
|
|
: base(rows, columns)
|
|
{
|
|
_rowCount = rows;
|
|
_columnCount = columns;
|
|
Data = array;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="DenseMatrix"/> class from a 2D array. This constructor
|
|
/// will allocate a completely new memory block for storing the dense matrix.
|
|
/// </summary>
|
|
/// <param name="array">The 2D array to create this matrix from.</param>
|
|
public DenseMatrix(Complex32[,] array)
|
|
: base(array.GetLength(0), array.GetLength(1))
|
|
{
|
|
_rowCount = array.GetLength(0);
|
|
_columnCount = array.GetLength(1);
|
|
Data = new Complex32[_rowCount * _columnCount];
|
|
for (var i = 0; i < _rowCount; i++)
|
|
{
|
|
for (var j = 0; j < _columnCount; j++)
|
|
{
|
|
Data[(j * _rowCount) + i] = array[i, j];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the matrix's data.
|
|
/// </summary>
|
|
/// <value>The matrix's data.</value>
|
|
public Complex32[] Data
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a <c>DenseMatrix</c> for the given number of rows and columns.
|
|
/// </summary>
|
|
/// <param name="numberOfRows">
|
|
/// The number of rows.
|
|
/// </param>
|
|
/// <param name="numberOfColumns">
|
|
/// The number of columns.
|
|
/// </param>
|
|
/// <returns>
|
|
/// A <c>DenseMatrix</c> with the given dimensions.
|
|
/// </returns>
|
|
public override Matrix<Complex32> CreateMatrix(int numberOfRows, int numberOfColumns)
|
|
{
|
|
return new DenseMatrix(numberOfRows, numberOfColumns);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a <see cref="Vector{T}"/> with a the given dimension.
|
|
/// </summary>
|
|
/// <param name="size">The size of the vector.</param>
|
|
/// <returns>
|
|
/// A <see cref="Vector{T}"/> with the given dimension.
|
|
/// </returns>
|
|
public override Vector<Complex32> CreateVector(int size)
|
|
{
|
|
return new DenseVector(size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of this matrix to the given matrix.
|
|
/// </summary>
|
|
/// <param name="target">
|
|
/// The matrix to copy values into.
|
|
/// </param>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// If target is <see langword="null"/>.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentException">
|
|
/// If this and the target matrix do not have the same dimensions..
|
|
/// </exception>
|
|
public override void CopyTo(Matrix<Complex32> target)
|
|
{
|
|
var denseTarget = target as DenseMatrix;
|
|
if (denseTarget == null)
|
|
{
|
|
base.CopyTo(target);
|
|
return;
|
|
}
|
|
|
|
if (ReferenceEquals(this, target))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (RowCount != target.RowCount || ColumnCount != target.ColumnCount)
|
|
{
|
|
throw DimensionsDontMatch<ArgumentException>(this, target, "target");
|
|
}
|
|
|
|
Array.Copy(Data, 0, denseTarget.Data, 0, Data.Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the value at the given row and column.
|
|
/// </summary>
|
|
/// <param name="row">
|
|
/// The row of the element.
|
|
/// </param>
|
|
/// <param name="column">
|
|
/// The column of the element.
|
|
/// </param>
|
|
/// <value>The value to get or set.</value>
|
|
/// <remarks>This method is ranged checked. <see cref="At(int,int)"/> and <see cref="At(int,int,Complex32)"/>
|
|
/// to get and set values without range checking.</remarks>
|
|
public override Complex32 this[int row, int column]
|
|
{
|
|
get
|
|
{
|
|
if (row < 0 || row >= _rowCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException("row");
|
|
}
|
|
|
|
if (column < 0 || column >= _columnCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException("column");
|
|
}
|
|
|
|
return Data[(column * _rowCount) + row];
|
|
}
|
|
|
|
set
|
|
{
|
|
if (row < 0 || row >= _rowCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException("row");
|
|
}
|
|
|
|
if (column < 0 || column >= _columnCount)
|
|
{
|
|
throw new ArgumentOutOfRangeException("column");
|
|
}
|
|
|
|
Data[(column * _rowCount) + row] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the requested element without range checking.
|
|
/// </summary>
|
|
/// <param name="row">
|
|
/// The row of the element.
|
|
/// </param>
|
|
/// <param name="column">
|
|
/// The column of the element.
|
|
/// </param>
|
|
/// <returns>
|
|
/// The requested element.
|
|
/// </returns>
|
|
public override Complex32 At(int row, int column)
|
|
{
|
|
return Data[(column * _rowCount) + row];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the value of the given element.
|
|
/// </summary>
|
|
/// <param name="row">
|
|
/// The row of the element.
|
|
/// </param>
|
|
/// <param name="column">
|
|
/// The column of the element.
|
|
/// </param>
|
|
/// <param name="value">
|
|
/// The value to set the element to.
|
|
/// </param>
|
|
public override void At(int row, int column, Complex32 value)
|
|
{
|
|
Data[(column * _rowCount) + row] = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets all values to zero.
|
|
/// </summary>
|
|
public override void Clear()
|
|
{
|
|
Array.Clear(Data, 0, Data.Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the transpose of this matrix.
|
|
/// </summary>
|
|
/// <returns>The transpose of this matrix.</returns>
|
|
public override Matrix<Complex32> Transpose()
|
|
{
|
|
var ret = new DenseMatrix(ColumnCount, RowCount);
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
var index = j * RowCount;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
ret.Data[(i * ColumnCount) + j] = Data[index + i];
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>Calculates the L1 norm.</summary>
|
|
/// <returns>The L1 norm of the matrix.</returns>
|
|
public override Complex32 L1Norm()
|
|
{
|
|
return Control.LinearAlgebraProvider.MatrixNorm(Norm.OneNorm, RowCount, ColumnCount, Data);
|
|
}
|
|
|
|
/// <summary>Calculates the Frobenius norm of this matrix.</summary>
|
|
/// <returns>The Frobenius norm of this matrix.</returns>
|
|
public override Complex32 FrobeniusNorm()
|
|
{
|
|
return Control.LinearAlgebraProvider.MatrixNorm(Norm.FrobeniusNorm, RowCount, ColumnCount, Data);
|
|
}
|
|
|
|
/// <summary>Calculates the infinity norm of this matrix.</summary>
|
|
/// <returns>The infinity norm of this matrix.</returns>
|
|
public override Complex32 InfinityNorm()
|
|
{
|
|
return Control.LinearAlgebraProvider.MatrixNorm(Norm.InfinityNorm, RowCount, ColumnCount, Data);
|
|
}
|
|
|
|
#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>
|
|
/// <returns>A dense identity matrix.</returns>
|
|
/// <exception cref="ArgumentException">
|
|
/// If <paramref name="order"/> is less than one.
|
|
/// </exception>
|
|
public static DenseMatrix Identity(int order)
|
|
{
|
|
var m = new DenseMatrix(order);
|
|
for (var i = 0; i < order; i++)
|
|
{
|
|
m.Data[(i * order) + i] = 1.0f;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <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(Complex32 scalar, Matrix<Complex32> result)
|
|
{
|
|
var denseResult = result as DenseMatrix;
|
|
if (denseResult == null)
|
|
{
|
|
base.DoMultiply(scalar, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.ScaleArray(scalar, Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> rightSide, Vector<Complex32> result)
|
|
{
|
|
var denseRight = rightSide as DenseVector;
|
|
var denseResult = result as DenseVector;
|
|
|
|
if (denseRight == null || denseResult == null)
|
|
{
|
|
base.DoMultiply(rightSide, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
1.0f,
|
|
Data,
|
|
RowCount,
|
|
ColumnCount,
|
|
denseRight.Data,
|
|
denseRight.Count,
|
|
1,
|
|
0.0f,
|
|
denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoMultiply(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
1.0f,
|
|
Data,
|
|
RowCount,
|
|
ColumnCount,
|
|
denseOther.Data,
|
|
denseOther.RowCount,
|
|
denseOther.ColumnCount,
|
|
0.0f,
|
|
denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoTransposeAndMultiply(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
Algorithms.LinearAlgebra.Transpose.Transpose,
|
|
1.0f,
|
|
Data,
|
|
RowCount,
|
|
ColumnCount,
|
|
denseOther.Data,
|
|
denseOther.RowCount,
|
|
denseOther.ColumnCount,
|
|
0.0f,
|
|
denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> rightSide, Vector<Complex32> result)
|
|
{
|
|
var denseRight = rightSide as DenseVector;
|
|
var denseResult = result as DenseVector;
|
|
|
|
if (denseRight == null || denseResult == null)
|
|
{
|
|
base.DoTransposeThisAndMultiply(rightSide, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(
|
|
Algorithms.LinearAlgebra.Transpose.Transpose,
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
1.0f,
|
|
Data,
|
|
RowCount,
|
|
ColumnCount,
|
|
denseRight.Data,
|
|
denseRight.Count,
|
|
1,
|
|
0.0f,
|
|
denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoTransposeThisAndMultiply(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.MatrixMultiplyWithUpdate(
|
|
Algorithms.LinearAlgebra.Transpose.Transpose,
|
|
Algorithms.LinearAlgebra.Transpose.DontTranspose,
|
|
1.0f,
|
|
Data,
|
|
RowCount,
|
|
ColumnCount,
|
|
denseOther.Data,
|
|
denseOther.RowCount,
|
|
denseOther.ColumnCount,
|
|
0.0f,
|
|
denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> result)
|
|
{
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseResult == null)
|
|
{
|
|
base.DoNegate(result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.ScaleArray(-1, Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoPointwiseMultiply(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.PointWiseMultiplyArrays(Data, denseOther.Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise divide this matrix by another matrix and stores the result into the result matrix.
|
|
/// </summary>
|
|
/// <param name="other">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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoPointwiseDivide(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.PointWiseDivideArrays(Data, denseOther.Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoAdd(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.AddArrays(Data, denseOther.Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <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<Complex32> other, Matrix<Complex32> result)
|
|
{
|
|
var denseOther = other as DenseMatrix;
|
|
var denseResult = result as DenseMatrix;
|
|
if (denseOther == null || denseResult == null)
|
|
{
|
|
base.DoSubtract(other, result);
|
|
}
|
|
else
|
|
{
|
|
Control.LinearAlgebraProvider.SubtractArrays(Data, denseOther.Data, denseResult.Data);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the conjugate transpose of this matrix.
|
|
/// </summary>
|
|
/// <returns>The conjugate transpose of this matrix.</returns>
|
|
public override Matrix<Complex32> ConjugateTranspose()
|
|
{
|
|
var ret = new DenseMatrix(ColumnCount, RowCount);
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
var index = j * RowCount;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
ret.Data[(i * ColumnCount) + j] = Data[index + i].Conjugate();
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/// <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 Complex32 Trace()
|
|
{
|
|
if (RowCount != ColumnCount)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixSquare);
|
|
}
|
|
|
|
var sum = Complex32.Zero;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
sum += Data[(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("rightSide");
|
|
}
|
|
|
|
if (leftSide == null)
|
|
{
|
|
throw new ArgumentNullException("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("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("rightSide");
|
|
}
|
|
|
|
if (leftSide == null)
|
|
{
|
|
throw new ArgumentNullException("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("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, Complex32 rightSide)
|
|
{
|
|
if (leftSide == null)
|
|
{
|
|
throw new ArgumentNullException("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 *(Complex32 leftSide, DenseMatrix rightSide)
|
|
{
|
|
if (rightSide == null)
|
|
{
|
|
throw new ArgumentNullException("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("leftSide");
|
|
}
|
|
|
|
if (rightSide == null)
|
|
{
|
|
throw new ArgumentNullException("rightSide");
|
|
}
|
|
|
|
if (leftSide.ColumnCount != rightSide.RowCount)
|
|
{
|
|
throw DimensionsDontMatch<ArgumentException>(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("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("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, Complex32 rightSide)
|
|
{
|
|
if (leftSide == null)
|
|
{
|
|
throw new ArgumentNullException("leftSide");
|
|
}
|
|
|
|
return (DenseMatrix)leftSide.Modulus(rightSide);
|
|
}
|
|
}
|
|
}
|
|
|