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.
697 lines
27 KiB
697 lines
27 KiB
// <copyright file="Matrix.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-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 MathNet.Numerics.LinearAlgebra.Double.Factorization;
|
|
using MathNet.Numerics.LinearAlgebra.Factorization;
|
|
using MathNet.Numerics.LinearAlgebra.Storage;
|
|
using MathNet.Numerics.Properties;
|
|
|
|
namespace MathNet.Numerics.LinearAlgebra.Double
|
|
{
|
|
/// <summary>
|
|
/// <c>double</c> version of the <see cref="Matrix{T}"/> class.
|
|
/// </summary>
|
|
[Serializable]
|
|
public abstract class Matrix : Matrix<double>
|
|
{
|
|
/// <summary>
|
|
/// Initializes a new instance of the Matrix class.
|
|
/// </summary>
|
|
protected Matrix(MatrixStorage<double> storage)
|
|
: base(storage)
|
|
{
|
|
}
|
|
|
|
/// <summary>Calculates the induced L1 norm of this matrix.</summary>
|
|
/// <returns>The maximum absolute column sum of the matrix.</returns>
|
|
public override double L1Norm()
|
|
{
|
|
var norm = 0d;
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
var s = 0d;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
s += Math.Abs(At(i, j));
|
|
}
|
|
norm = Math.Max(norm, s);
|
|
}
|
|
return norm;
|
|
}
|
|
|
|
/// <summary>Calculates the induced infinity norm of this matrix.</summary>
|
|
/// <returns>The maximum absolute row sum of the matrix.</returns>
|
|
public override double InfinityNorm()
|
|
{
|
|
var norm = 0d;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
var s = 0d;
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
s += Math.Abs(At(i, j));
|
|
}
|
|
norm = Math.Max(norm, s);
|
|
}
|
|
return norm;
|
|
}
|
|
|
|
/// <summary>Calculates the entry-wise Frobenius norm of this matrix.</summary>
|
|
/// <returns>The square root of the sum of the squared values.</returns>
|
|
public override double FrobeniusNorm()
|
|
{
|
|
var transpose = Transpose();
|
|
var aat = this*transpose;
|
|
var norm = 0d;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
norm += aat.At(i, i);
|
|
}
|
|
return Math.Sqrt(norm);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the p-norms of all row vectors.
|
|
/// Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm)
|
|
/// </summary>
|
|
public override Vector<double> RowNorms(double norm)
|
|
{
|
|
if (norm <= 0.0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("norm", Resources.ArgumentMustBePositive);
|
|
}
|
|
|
|
var ret = Vector<double>.Build.Dense(RowCount);
|
|
if (norm == 2.0)
|
|
{
|
|
Storage.FoldRowsUnchecked(ret.Storage, (s, x) => s + x*x, (x, c) => Math.Sqrt(x), ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else if (norm == 1.0)
|
|
{
|
|
Storage.FoldRowsUnchecked(ret.Storage, (s, x) => s + Math.Abs(x), (x, c) => x, ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else if (double.IsPositiveInfinity(norm))
|
|
{
|
|
Storage.FoldRowsUnchecked(ret.Storage, (s, x) => Math.Max(s, Math.Abs(x)), (x, c) => x, ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else
|
|
{
|
|
double invnorm = 1.0/norm;
|
|
Storage.FoldRowsUnchecked(ret.Storage, (s, x) => s + Math.Pow(Math.Abs(x), norm), (x, c) => Math.Pow(x, invnorm), ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the p-norms of all column vectors.
|
|
/// Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm)
|
|
/// </summary>
|
|
public override Vector<double> ColumnNorms(double norm)
|
|
{
|
|
if (norm <= 0.0)
|
|
{
|
|
throw new ArgumentOutOfRangeException("norm", Resources.ArgumentMustBePositive);
|
|
}
|
|
|
|
var ret = Vector<double>.Build.Dense(ColumnCount);
|
|
if (norm == 2.0)
|
|
{
|
|
Storage.FoldColumnsUnchecked(ret.Storage, (s, x) => s + x*x, (x, c) => Math.Sqrt(x), ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else if (norm == 1.0)
|
|
{
|
|
Storage.FoldColumnsUnchecked(ret.Storage, (s, x) => s + Math.Abs(x), (x, c) => x, ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else if (double.IsPositiveInfinity(norm))
|
|
{
|
|
Storage.FoldColumnsUnchecked(ret.Storage, (s, x) => Math.Max(s, Math.Abs(x)), (x, c) => x, ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
else
|
|
{
|
|
double invnorm = 1.0/norm;
|
|
Storage.FoldColumnsUnchecked(ret.Storage, (s, x) => s + Math.Pow(Math.Abs(x), norm), (x, c) => Math.Pow(x, invnorm), ret.Storage, Zeros.AllowSkip);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Normalizes all row vectors to a unit p-norm.
|
|
/// Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm)
|
|
/// </summary>
|
|
public override sealed Matrix<double> NormalizeRows(double norm)
|
|
{
|
|
var norminv = ((DenseVectorStorage<double>)RowNorms(norm).Storage).Data;
|
|
for (int i = 0; i < norminv.Length; i++)
|
|
{
|
|
norminv[i] = norminv[i] == 0d ? 1d : 1d/norminv[i];
|
|
}
|
|
|
|
var result = Build.SameAs(this, RowCount, ColumnCount);
|
|
Storage.MapIndexedTo(result.Storage, (i, j, x) => norminv[i]*x, Zeros.AllowSkip, ExistingData.AssumeZeros);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Normalizes all column vectors to a unit p-norm.
|
|
/// Typical values for p are 1.0 (L1, Manhattan norm), 2.0 (L2, Euclidean norm) and positive infinity (infinity norm)
|
|
/// </summary>
|
|
public override sealed Matrix<double> NormalizeColumns(double norm)
|
|
{
|
|
var norminv = ((DenseVectorStorage<double>)ColumnNorms(norm).Storage).Data;
|
|
for (int i = 0; i < norminv.Length; i++)
|
|
{
|
|
norminv[i] = norminv[i] == 0d ? 1d : 1d/norminv[i];
|
|
}
|
|
|
|
var result = Build.SameAs(this, RowCount, ColumnCount);
|
|
Storage.MapIndexedTo(result.Storage, (i, j, x) => norminv[j]*x, Zeros.AllowSkip, ExistingData.AssumeZeros);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the conjugate transpose of this matrix.
|
|
/// </summary>
|
|
/// <returns>The conjugate transpose of this matrix.</returns>
|
|
public override sealed Matrix<double> ConjugateTranspose()
|
|
{
|
|
return Transpose();
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, At(i, j) + scalar);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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 the addition.</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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, At(i, j) + other.At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtracts a scalar from each element of the vector 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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, At(i, j) - scalar);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtracts another matrix from this matrix.
|
|
/// </summary>
|
|
/// <param name="other">The matrix to subtract to this matrix.</param>
|
|
/// <param name="result">The matrix to store the result of subtraction.</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 DoSubtract(Matrix<double> other, Matrix<double> result)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, At(i, j) - other.At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, At(i, j)*scalar);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
var s = 0.0;
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
s += At(i, j)*rightSide[j];
|
|
}
|
|
result[i] = s;
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
DoMultiply(1.0/divisor, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides a scalar by each element of the matrix and stores the result in the result matrix.
|
|
/// </summary>
|
|
/// <param name="dividend">The scalar to add.</param>
|
|
/// <param name="result">The matrix to store the result of the division.</param>
|
|
protected override void DoDivideByThis(double dividend, Matrix<double> result)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, dividend/At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var j = 0; j < RowCount; j++)
|
|
{
|
|
for (var i = 0; i < other.ColumnCount; i++)
|
|
{
|
|
var s = 0.0;
|
|
for (var l = 0; l < ColumnCount; l++)
|
|
{
|
|
s += At(j, l)*other.At(l, i);
|
|
}
|
|
result.At(j, i, s);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var j = 0; j < other.RowCount; j++)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
var s = 0.0;
|
|
for (var l = 0; l < ColumnCount; l++)
|
|
{
|
|
s += At(i, l)*other.At(j, l);
|
|
}
|
|
result.At(i, j, s);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies this matrix with the conjugate 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 sealed void DoConjugateTransposeAndMultiply(Matrix<double> other, Matrix<double> result)
|
|
{
|
|
DoTransposeAndMultiply(other, 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)
|
|
{
|
|
for (var j = 0; j < other.ColumnCount; j++)
|
|
{
|
|
for (var i = 0; i < ColumnCount; i++)
|
|
{
|
|
var s = 0.0;
|
|
for (var l = 0; l < RowCount; l++)
|
|
{
|
|
s += At(l, i)*other.At(l, j);
|
|
}
|
|
result.At(i, j, s);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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 sealed void DoConjugateTransposeThisAndMultiply(Matrix<double> other, Matrix<double> result)
|
|
{
|
|
DoTransposeThisAndMultiply(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)
|
|
{
|
|
for (var i = 0; i < ColumnCount; i++)
|
|
{
|
|
var s = 0.0;
|
|
for (var j = 0; j < RowCount; j++)
|
|
{
|
|
s += At(j, i)*rightSide[j];
|
|
}
|
|
result[i] = s;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies the conjugate 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 DoConjugateTransposeThisAndMultiply(Vector<double> rightSide, Vector<double> result)
|
|
{
|
|
DoTransposeThisAndMultiply(rightSide, result);
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
result.At(i, j, -At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Complex conjugates each element of this matrix and place the results into the result matrix.
|
|
/// </summary>
|
|
/// <param name="result">The result of the conjugation.</param>
|
|
protected override sealed void DoConjugate(Matrix<double> result)
|
|
{
|
|
if (ReferenceEquals(this, result))
|
|
{
|
|
return;
|
|
}
|
|
|
|
CopyTo(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)
|
|
{
|
|
for (var row = 0; row < RowCount; row++)
|
|
{
|
|
for (var column = 0; column < ColumnCount; column++)
|
|
{
|
|
result.At(row, column, Euclid.Modulus(At(row, column), divisor));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var row = 0; row < RowCount; row++)
|
|
{
|
|
for (var column = 0; column < ColumnCount; column++)
|
|
{
|
|
result.At(row, column, Euclid.Modulus(dividend, At(row, column)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var row = 0; row < RowCount; row++)
|
|
{
|
|
for (var column = 0; column < ColumnCount; column++)
|
|
{
|
|
result.At(row, column, At(row, column)%divisor);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var row = 0; row < RowCount; row++)
|
|
{
|
|
for (var column = 0; column < ColumnCount; column++)
|
|
{
|
|
result.At(row, column, dividend%At(row, column));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
result.At(i, j, At(i, j)*other.At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
result.At(i, j, At(i, j)/divisor.At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise raise this matrix to an exponent and store the result into the result vector.
|
|
/// </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(double exponent, Matrix<double> result)
|
|
{
|
|
Map(x => Math.Pow(x, exponent), result, Zeros.AllowSkip);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise canonical modulus, where the result has the sign of the divisor,
|
|
/// of this matrix with another matrix and stores the result into the result matrix.
|
|
/// </summary>
|
|
/// <param name="divisor">The pointwise denominator matrix to use</param>
|
|
/// <param name="result">The result of the modulus.</param>
|
|
protected override void DoPointwiseModulus(Matrix<double> divisor, Matrix<double> result)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
result.At(i, j, Euclid.Modulus(At(i, j), divisor.At(i, j)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise remainder (% operator), where the result has the sign of the dividend,
|
|
/// of this matrix with another matrix and stores the result into the result matrix.
|
|
/// </summary>
|
|
/// <param name="divisor">The pointwise denominator matrix to use</param>
|
|
/// <param name="result">The result of the modulus.</param>
|
|
protected override void DoPointwiseRemainder(Matrix<double> divisor, Matrix<double> result)
|
|
{
|
|
for (var j = 0; j < ColumnCount; j++)
|
|
{
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
result.At(i, j, At(i, j)%divisor.At(i, j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise applies the exponential function to each value and stores the result into the result matrix.
|
|
/// </summary>
|
|
/// <param name="result">The matrix to store the result.</param>
|
|
protected override void DoPointwiseExp(Matrix<double> result)
|
|
{
|
|
Map(Math.Exp, result, Zeros.Include);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pointwise applies the natural logarithm function to each value and stores the result into the result matrix.
|
|
/// </summary>
|
|
/// <param name="result">The matrix to store the result.</param>
|
|
protected override void DoPointwiseLog(Matrix<double> result)
|
|
{
|
|
Map(Math.Log, result, Zeros.Include);
|
|
}
|
|
|
|
/// <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(Resources.ArgumentMatrixSquare);
|
|
}
|
|
|
|
var sum = 0.0;
|
|
for (var i = 0; i < RowCount; i++)
|
|
{
|
|
sum += At(i, i);
|
|
}
|
|
|
|
return sum;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Evaluates whether this matrix is conjugate symmetric.
|
|
/// </summary>
|
|
public override sealed bool IsConjugateSymmetric()
|
|
{
|
|
return IsSymmetric();
|
|
}
|
|
|
|
public override Cholesky<double> Cholesky()
|
|
{
|
|
return UserCholesky.Create(this);
|
|
}
|
|
|
|
public override LU<double> LU()
|
|
{
|
|
return UserLU.Create(this);
|
|
}
|
|
|
|
public override QR<double> QR(QRMethod method = QRMethod.Thin)
|
|
{
|
|
return UserQR.Create(this, method);
|
|
}
|
|
|
|
public override GramSchmidt<double> GramSchmidt()
|
|
{
|
|
return UserGramSchmidt.Create(this);
|
|
}
|
|
|
|
public override Svd<double> Svd(bool computeVectors = true)
|
|
{
|
|
return UserSvd.Create(this, computeVectors);
|
|
}
|
|
|
|
public override Evd<double> Evd()
|
|
{
|
|
return UserEvd.Create(this);
|
|
}
|
|
}
|
|
}
|
|
|