csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
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.
2426 lines
107 KiB
2426 lines
107 KiB
// <copyright file="AtlasLinearAlgebraProvider.cs" company="Math.NET">
|
|
// Math.NET Numerics, part of the Math.NET Project
|
|
// http://mathnet.opensourcedotnet.info
|
|
// Copyright (c) 2009 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>
|
|
|
|
/* This file is automatically generated - do not modify it.
|
|
Change NativeLinearAlgebraProvider.include instead.
|
|
Last generated on: 4/23/2010 10:04:38 AM
|
|
*/
|
|
namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
|
|
{
|
|
using System;
|
|
using System.Numerics;
|
|
using Properties;
|
|
|
|
/// <summary>
|
|
/// The managed linear algebra provider.
|
|
/// </summary>
|
|
public class AtlasLinearAlgebraProvider : ILinearAlgebraProvider
|
|
{
|
|
private readonly ILinearAlgebraProvider _managedProvider = new ManagedLinearAlgebraProvider();
|
|
|
|
#region ILinearAlgebraProvider<double> Members
|
|
|
|
/// <summary>
|
|
/// Adds a scaled vector to another: <c>y += alpha*x</c>.
|
|
/// </summary>
|
|
/// <param name="y">The vector to update.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="x"/> by.</param>
|
|
/// <param name="x">The vector to add to <paramref name="y"/>.</param>
|
|
/// <remarks>This equivalent to the AXPY BLAS routine.</remarks>
|
|
public void AddVectorToScaledVector(double[] y, double alpha, double[] x)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (y.Length != x.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
|
|
}
|
|
|
|
if (alpha == 0.0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.d_axpy(y.Length, alpha, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scales an array. Can be used to scale a vector and a matrix.
|
|
/// </summary>
|
|
/// <param name="alpha">The scalar.</param>
|
|
/// <param name="x">The values to scale.</param>
|
|
/// <remarks>This is equivalent to the SCAL BLAS routine.</remarks>
|
|
public void ScaleArray(double alpha, double[] x)
|
|
{
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (alpha == 1.0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.d_scale(x.Length, alpha, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the dot product of x and y.
|
|
/// </summary>
|
|
/// <param name="x">The vector x.</param>
|
|
/// <param name="y">The vector y.</param>
|
|
/// <returns>The dot product of x and y.</returns>
|
|
/// <remarks>This is equivalent to the DOT BLAS routine.</remarks>
|
|
public double DotProduct(double[] x, double[] y)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
return SafeNativeMethods.d_dot_product(x.Length, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise add of two arrays <c>z = x + y</c>. This can be used
|
|
/// to add vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the addition.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void AddArrays(double[] x, double[] y, double[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.AddArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise subtraction of two arrays <c>z = x - y</c>. This can be used
|
|
/// to subtract vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the subtraction.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void SubtractArrays(double[] x, double[] y, double[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.SubtractArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise multiplication of two arrays <c>z = x * y</c>. This can be used
|
|
/// to multiple elements of vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the point wise multiplication.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void PointWiseMultiplyArrays(double[] x, double[] y, double[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.PointWiseMultiplyArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public double MatrixNorm(Norm norm, double[] matrix)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <param name="work">The work array. Only used when <see cref="Norm.InfinityNorm"/>
|
|
/// and needs to be have a length of at least M (number of rows of <paramref name="matrix"/>.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public double MatrixNorm(Norm norm, double[] matrix, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiples two matrices. <c>result = x * y</c>
|
|
/// </summary>
|
|
/// <param name="x">The x matrix.</param>
|
|
/// <param name="xRows">The number of rows in the x matrix.</param>
|
|
/// <param name="xColumns">The number of columns in the x matrix.</param>
|
|
/// <param name="y">The y matrix.</param>
|
|
/// <param name="yRows">The number of rows in the y matrix.</param>
|
|
/// <param name="yColumns">The number of columns in the y matrix.</param>
|
|
/// <param name="result">Where to store the result of the multiplication.</param>
|
|
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
|
|
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
|
|
public void MatrixMultiply(double[] x, int xRows, int xColumns, double[] y, int yRows, int yColumns, double[] result)
|
|
{
|
|
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 1.0, x, xRows, xColumns, y, yRows, yColumns, 0.0, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
|
|
/// <param name="a">The a matrix.</param>
|
|
/// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="b">The b matrix</param>
|
|
/// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
|
|
/// <param name="c">The c matrix.</param>
|
|
public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a,
|
|
int aRows, int aColumns, double[] b, int bRows, int bColumns, double beta, double[] c)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if (b == null)
|
|
{
|
|
throw new ArgumentNullException("b");
|
|
}
|
|
|
|
if (c == null)
|
|
{
|
|
throw new ArgumentNullException("c");
|
|
}
|
|
|
|
var m = transposeA == Transpose.DontTranspose ? aRows : aColumns;
|
|
var n = transposeB == Transpose.DontTranspose ? bColumns : bRows;
|
|
var k = transposeA == Transpose.DontTranspose ? aColumns : aRows;
|
|
|
|
if( c.Length != aRows * bColumns)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
if (aColumns != bRows)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
SafeNativeMethods.d_matrix_multiply(transposeA, transposeB, m, n, k, alpha, a, b, beta, c);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the LU factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">An m by n matrix. The matrix is overwritten with the
|
|
/// the LU factorization On exit.</param>
|
|
/// <param name="ipiv">On exit, it contains the pivot indices. The size
|
|
/// of the array must be min(m,n).</param>
|
|
/// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
|
|
public void LUFactor(double[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(double[] a)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(double[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(double[] a, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(double[] a, int[] ipiv, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(int columnsOfB, double[] a, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(int columnsOfB, double[] a, int ipiv, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(Transpose transposeA, int columnsOfB, double[] a, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(Transpose transposeA, int columnsOfB, double[] a, int ipiv, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the Cholesky factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
|
|
/// the Cholesky factorization.</param>
|
|
/// <param name="order">The number of rows or columns in the matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF LAPACK routine.</remarks>
|
|
public void CholeskyFactor(double[] a, int order)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if ( order < 1)
|
|
{
|
|
throw new ArgumentException(Properties.Resources.ArgumentMustBePositive, "order");
|
|
}
|
|
|
|
SafeNativeMethods.d_cholesky_factor(order, a);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using Cholesky factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square, positive definite matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF add POTRS LAPACK routines.</remarks>
|
|
public void CholeskySolve(int columnsOfB, double[] a, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRS LAPACK routine.</remarks>
|
|
public void CholeskySolveFactored(int columnsOfB, double[] a, double[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
|
|
public void QRFactor(double[] r, double[] q)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRFactor(double[] r, double[] q, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously QR factored matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="q">The Q matrix obtained by calling <see cref="QRFactor(double[],double[])"/>.</param>
|
|
/// <param name="r">The R matrix obtained by calling <see cref="QRFactor(double[],double[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolveFactored(int columnsOfB, double[] q, double[] r, double[] b, double[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SinguarValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SingularValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x, double[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously SVD decomposed matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="s">The s values returned by <see cref="SinguarValueDecomposition(bool,double[],double[],double[],double[])"/>.</param>
|
|
/// <param name="u">The left singular vectors returned by <see cref="SinguarValueDecomposition(bool,double[],double[],double[],double[])"/>.</param>
|
|
/// <param name="vt">The right singular vectors returned by <see cref="SinguarValueDecomposition(bool,double[],double[],double[],double[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolveFactored(int columnsOfB, double[] s, double[] u, double[] vt, double[] b, double[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ILinearAlgebraProvider<float> Members
|
|
|
|
/// <summary>
|
|
/// Adds a scaled vector to another: <c>y += alpha*x</c>.
|
|
/// </summary>
|
|
/// <param name="y">The vector to update.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="x"/> by.</param>
|
|
/// <param name="x">The vector to add to <paramref name="y"/>.</param>
|
|
/// <remarks>This equivalent to the AXPY BLAS routine.</remarks>
|
|
public void AddVectorToScaledVector(float[] y, float alpha, float[] x)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (y.Length != x.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
|
|
}
|
|
|
|
if (alpha == 0.0f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.s_axpy(y.Length, alpha, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scales an array. Can be used to scale a vector and a matrix.
|
|
/// </summary>
|
|
/// <param name="alpha">The scalar.</param>
|
|
/// <param name="x">The values to scale.</param>
|
|
/// <remarks>This is equivalent to the SCAL BLAS routine.</remarks>
|
|
public void ScaleArray(float alpha, float[] x)
|
|
{
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (alpha == 1.0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.s_scale(x.Length, alpha, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the dot product of x and y.
|
|
/// </summary>
|
|
/// <param name="x">The vector x.</param>
|
|
/// <param name="y">The vector y.</param>
|
|
/// <returns>The dot product of x and y.</returns>
|
|
/// <remarks>This is equivalent to the DOT BLAS routine.</remarks>
|
|
public float DotProduct(float[] x, float[] y)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
return SafeNativeMethods.s_dot_product(x.Length, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise add of two arrays <c>z = x + y</c>. This can be used
|
|
/// to add vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the addition.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void AddArrays(float[] x, float[] y, float[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.AddArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise subtraction of two arrays <c>z = x - y</c>. This can be used
|
|
/// to subtract vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the subtraction.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void SubtractArrays(float[] x, float[] y, float[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.SubtractArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise multiplication of two arrays <c>z = x * y</c>. This can be used
|
|
/// to multiple elements of vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the point wise multiplication.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void PointWiseMultiplyArrays(float[] x, float[] y, float[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.PointWiseMultiplyArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public float MatrixNorm(Norm norm, float[] matrix)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <param name="work">The work array. Only used when <see cref="Norm.InfinityNorm"/>
|
|
/// and needs to be have a length of at least M (number of rows of <paramref name="matrix"/>.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public float MatrixNorm(Norm norm, float[] matrix, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiples two matrices. <c>result = x * y</c>
|
|
/// </summary>
|
|
/// <param name="x">The x matrix.</param>
|
|
/// <param name="xRows">The number of rows in the x matrix.</param>
|
|
/// <param name="xColumns">The number of columns in the x matrix.</param>
|
|
/// <param name="y">The y matrix.</param>
|
|
/// <param name="yRows">The number of rows in the y matrix.</param>
|
|
/// <param name="yColumns">The number of columns in the y matrix.</param>
|
|
/// <param name="result">Where to store the result of the multiplication.</param>
|
|
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
|
|
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
|
|
public void MatrixMultiply(float[] x, int xRows, int xColumns, float[] y, int yRows, int yColumns, float[] result)
|
|
{
|
|
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 1.0f, x, xRows, xColumns, y, yRows, yColumns, 0.0f, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
|
|
/// <param name="a">The a matrix.</param>
|
|
/// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="b">The b matrix</param>
|
|
/// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
|
|
/// <param name="c">The c matrix.</param>
|
|
public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a,
|
|
int aRows, int aColumns, float[] b, int bRows, int bColumns, float beta, float[] c)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if (b == null)
|
|
{
|
|
throw new ArgumentNullException("b");
|
|
}
|
|
|
|
if (c == null)
|
|
{
|
|
throw new ArgumentNullException("c");
|
|
}
|
|
|
|
var m = transposeA == Transpose.DontTranspose ? aRows : aColumns;
|
|
var n = transposeB == Transpose.DontTranspose ? bColumns : bRows;
|
|
var k = transposeA == Transpose.DontTranspose ? aColumns : aRows;
|
|
|
|
if( c.Length != aRows * bColumns)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
if (aColumns != bRows)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
SafeNativeMethods.s_matrix_multiply(transposeA, transposeB, m, n, k, alpha, a, b, beta, c);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the LU factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">An m by n matrix. The matrix is overwritten with the
|
|
/// the LU factorization On exit.</param>
|
|
/// <param name="ipiv">On exit, it contains the pivot indices. The size
|
|
/// of the array must be min(m,n).</param>
|
|
/// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
|
|
public void LUFactor(float[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(float[] a)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(float[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(float[] a, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(float[] a, int[] ipiv, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(int columnsOfB, float[] a, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(int columnsOfB, float[] a, int ipiv, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(Transpose transposeA, int columnsOfB, float[] a, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(Transpose transposeA, int columnsOfB, float[] a, int ipiv, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the Cholesky factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
|
|
/// the Cholesky factorization.</param>
|
|
/// <param name="order">The number of rows or columns in the matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF LAPACK routine.</remarks>
|
|
public void CholeskyFactor(float[] a, int order)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if ( order < 1)
|
|
{
|
|
throw new ArgumentException(Properties.Resources.ArgumentMustBePositive, "order");
|
|
}
|
|
|
|
SafeNativeMethods.s_cholesky_factor(order, a);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using Cholesky factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square, positive definite matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF add POTRS LAPACK routines.</remarks>
|
|
public void CholeskySolve(int columnsOfB, float[] a, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRS LAPACK routine.</remarks>
|
|
public void CholeskySolveFactored(int columnsOfB, float[] a, float[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
|
|
public void QRFactor(float[] r, float[] q)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRFactor(float[] r, float[] q, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously QR factored matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="q">The Q matrix obtained by calling <see cref="QRFactor(float[],float[])"/>.</param>
|
|
/// <param name="r">The R matrix obtained by calling <see cref="QRFactor(float[],float[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolveFactored(int columnsOfB, float[] q, float[] r, float[] b, float[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SinguarValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SingularValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x, float[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously SVD decomposed matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="s">The s values returned by <see cref="SinguarValueDecomposition(bool,float[],float[],float[],float[])"/>.</param>
|
|
/// <param name="u">The left singular vectors returned by <see cref="SinguarValueDecomposition(bool,float[],float[],float[],float[])"/>.</param>
|
|
/// <param name="vt">The right singular vectors returned by <see cref="SinguarValueDecomposition(bool,float[],float[],float[],float[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolveFactored(int columnsOfB, float[] s, float[] u, float[] vt, float[] b, float[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ILinearAlgebraProvider<Complex> Members
|
|
|
|
/// <summary>
|
|
/// Adds a scaled vector to another: <c>y += alpha*x</c>.
|
|
/// </summary>
|
|
/// <param name="y">The vector to update.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="x"/> by.</param>
|
|
/// <param name="x">The vector to add to <paramref name="y"/>.</param>
|
|
/// <remarks>This equivalent to the AXPY BLAS routine.</remarks>
|
|
public void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (y.Length != x.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
|
|
}
|
|
|
|
if (alpha.IsZero())
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.z_axpy(y.Length, ref alpha, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scales an array. Can be used to scale a vector and a matrix.
|
|
/// </summary>
|
|
/// <param name="alpha">The scalar.</param>
|
|
/// <param name="x">The values to scale.</param>
|
|
/// <remarks>This is equivalent to the SCAL BLAS routine.</remarks>
|
|
public void ScaleArray(Complex alpha, Complex[] x)
|
|
{
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (alpha.IsOne())
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.z_scale(x.Length, ref alpha, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the dot product of x and y.
|
|
/// </summary>
|
|
/// <param name="x">The vector x.</param>
|
|
/// <param name="y">The vector y.</param>
|
|
/// <returns>The dot product of x and y.</returns>
|
|
/// <remarks>This is equivalent to the DOT BLAS routine.</remarks>
|
|
public Complex DotProduct(Complex[] x, Complex[] y)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
return SafeNativeMethods.z_dot_product(x.Length, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise add of two arrays <c>z = x + y</c>. This can be used
|
|
/// to add vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the addition.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void AddArrays(Complex[] x, Complex[] y, Complex[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.AddArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise subtraction of two arrays <c>z = x - y</c>. This can be used
|
|
/// to subtract vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the subtraction.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void SubtractArrays(Complex[] x, Complex[] y, Complex[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.SubtractArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise multiplication of two arrays <c>z = x * y</c>. This can be used
|
|
/// to multiple elements of vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the point wise multiplication.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void PointWiseMultiplyArrays(Complex[] x, Complex[] y, Complex[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.PointWiseMultiplyArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public Complex MatrixNorm(Norm norm, Complex[] matrix)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <param name="work">The work array. Only used when <see cref="Norm.InfinityNorm"/>
|
|
/// and needs to be have a length of at least M (number of rows of <paramref name="matrix"/>.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public Complex MatrixNorm(Norm norm, Complex[] matrix, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiples two matrices. <c>result = x * y</c>
|
|
/// </summary>
|
|
/// <param name="x">The x matrix.</param>
|
|
/// <param name="xRows">The number of rows in the x matrix.</param>
|
|
/// <param name="xColumns">The number of columns in the x matrix.</param>
|
|
/// <param name="y">The y matrix.</param>
|
|
/// <param name="yRows">The number of rows in the y matrix.</param>
|
|
/// <param name="yColumns">The number of columns in the y matrix.</param>
|
|
/// <param name="result">Where to store the result of the multiplication.</param>
|
|
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
|
|
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
|
|
public void MatrixMultiply(Complex[] x, int xRows, int xColumns, Complex[] y, int yRows, int yColumns, Complex[] result)
|
|
{
|
|
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, Complex.One, x, xRows, xColumns, y, yRows, yColumns, Complex.Zero, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
|
|
/// <param name="a">The a matrix.</param>
|
|
/// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="b">The b matrix</param>
|
|
/// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
|
|
/// <param name="c">The c matrix.</param>
|
|
public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a,
|
|
int aRows, int aColumns, Complex[] b, int bRows, int bColumns, Complex beta, Complex[] c)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if (b == null)
|
|
{
|
|
throw new ArgumentNullException("b");
|
|
}
|
|
|
|
if (c == null)
|
|
{
|
|
throw new ArgumentNullException("c");
|
|
}
|
|
|
|
var m = transposeA == Transpose.DontTranspose ? aRows : aColumns;
|
|
var n = transposeB == Transpose.DontTranspose ? bColumns : bRows;
|
|
var k = transposeA == Transpose.DontTranspose ? aColumns : aRows;
|
|
|
|
if( c.Length != aRows * bColumns)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
if (aColumns != bRows)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
SafeNativeMethods.z_matrix_multiply(transposeA, transposeB, m, n, k, ref alpha, a, b, ref beta, c);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the LU factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">An m by n matrix. The matrix is overwritten with the
|
|
/// the LU factorization On exit.</param>
|
|
/// <param name="ipiv">On exit, it contains the pivot indices. The size
|
|
/// of the array must be min(m,n).</param>
|
|
/// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
|
|
public void LUFactor(Complex[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(Complex[] a)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(Complex[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(Complex[] a, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(Complex[] a, int[] ipiv, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(int columnsOfB, Complex[] a, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(int columnsOfB, Complex[] a, int ipiv, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(Transpose transposeA, int columnsOfB, Complex[] a, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex[] a, int ipiv, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the Cholesky factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
|
|
/// the Cholesky factorization.</param>
|
|
/// <param name="order">The number of rows or columns in the matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF LAPACK routine.</remarks>
|
|
public void CholeskyFactor(Complex[] a, int order)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if ( order < 1)
|
|
{
|
|
throw new ArgumentException(Properties.Resources.ArgumentMustBePositive, "order");
|
|
}
|
|
|
|
SafeNativeMethods.z_cholesky_factor(order, a);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using Cholesky factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square, positive definite matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF add POTRS LAPACK routines.</remarks>
|
|
public void CholeskySolve(int columnsOfB, Complex[] a, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRS LAPACK routine.</remarks>
|
|
public void CholeskySolveFactored(int columnsOfB, Complex[] a, Complex[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
|
|
public void QRFactor(Complex[] r, Complex[] q)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRFactor(Complex[] r, Complex[] q, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously QR factored matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="q">The Q matrix obtained by calling <see cref="QRFactor(Complex[],Complex[])"/>.</param>
|
|
/// <param name="r">The R matrix obtained by calling <see cref="QRFactor(Complex[],Complex[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolveFactored(int columnsOfB, Complex[] q, Complex[] r, Complex[] b, Complex[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SinguarValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SingularValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x, Complex[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously SVD decomposed matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="s">The s values returned by <see cref="SinguarValueDecomposition(bool,Complex[],Complex[],Complex[],Complex[])"/>.</param>
|
|
/// <param name="u">The left singular vectors returned by <see cref="SinguarValueDecomposition(bool,Complex[],Complex[],Complex[],Complex[])"/>.</param>
|
|
/// <param name="vt">The right singular vectors returned by <see cref="SinguarValueDecomposition(bool,Complex[],Complex[],Complex[],Complex[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolveFactored(int columnsOfB, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ILinearAlgebraProvider<Complex32> Members
|
|
|
|
/// <summary>
|
|
/// Adds a scaled vector to another: <c>y += alpha*x</c>.
|
|
/// </summary>
|
|
/// <param name="y">The vector to update.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="x"/> by.</param>
|
|
/// <param name="x">The vector to add to <paramref name="y"/>.</param>
|
|
/// <remarks>This equivalent to the AXPY BLAS routine.</remarks>
|
|
public void AddVectorToScaledVector(Complex32[] y, Complex32 alpha, Complex32[] x)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (y.Length != x.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
|
|
}
|
|
|
|
if (alpha.IsZero())
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.c_axpy(y.Length, ref alpha, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scales an array. Can be used to scale a vector and a matrix.
|
|
/// </summary>
|
|
/// <param name="alpha">The scalar.</param>
|
|
/// <param name="x">The values to scale.</param>
|
|
/// <remarks>This is equivalent to the SCAL BLAS routine.</remarks>
|
|
public void ScaleArray(Complex32 alpha, Complex32[] x)
|
|
{
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (alpha.IsOne())
|
|
{
|
|
return;
|
|
}
|
|
|
|
SafeNativeMethods.c_scale(x.Length, ref alpha, x);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the dot product of x and y.
|
|
/// </summary>
|
|
/// <param name="x">The vector x.</param>
|
|
/// <param name="y">The vector y.</param>
|
|
/// <returns>The dot product of x and y.</returns>
|
|
/// <remarks>This is equivalent to the DOT BLAS routine.</remarks>
|
|
public Complex32 DotProduct(Complex32[] x, Complex32[] y)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
return SafeNativeMethods.c_dot_product(x.Length, x, y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise add of two arrays <c>z = x + y</c>. This can be used
|
|
/// to add vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the addition.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void AddArrays(Complex32[] x, Complex32[] y, Complex32[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.AddArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise subtraction of two arrays <c>z = x - y</c>. This can be used
|
|
/// to subtract vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the subtraction.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void SubtractArrays(Complex32[] x, Complex32[] y, Complex32[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.SubtractArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does a point wise multiplication of two arrays <c>z = x * y</c>. This can be used
|
|
/// to multiple elements of vectors or matrices.
|
|
/// </summary>
|
|
/// <param name="x">The array x.</param>
|
|
/// <param name="y">The array y.</param>
|
|
/// <param name="result">The result of the point wise multiplication.</param>
|
|
/// <remarks>There is no equivalent BLAS routine, but many libraries
|
|
/// provide optimized (parallel and/or vectorized) versions of this
|
|
/// routine.</remarks>
|
|
public void PointWiseMultiplyArrays(Complex32[] x, Complex32[] y, Complex32[] result)
|
|
{
|
|
if (y == null)
|
|
{
|
|
throw new ArgumentNullException("y");
|
|
}
|
|
|
|
if (x == null)
|
|
{
|
|
throw new ArgumentNullException("x");
|
|
}
|
|
|
|
if (x.Length != y.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
if (x.Length != result.Length)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentArraysSameLength);
|
|
}
|
|
|
|
_managedProvider.PointWiseMultiplyArrays(x, y, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public Complex32 MatrixNorm(Norm norm, Complex32[] matrix)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the requested <see cref="Norm"/> of the matrix.
|
|
/// </summary>
|
|
/// <param name="norm">The type of norm to compute.</param>
|
|
/// <param name="matrix">The matrix to compute the norm from.</param>
|
|
/// <param name="work">The work array. Only used when <see cref="Norm.InfinityNorm"/>
|
|
/// and needs to be have a length of at least M (number of rows of <paramref name="matrix"/>.</param>
|
|
/// <returns>
|
|
/// The requested <see cref="Norm"/> of the matrix.
|
|
/// </returns>
|
|
public Complex32 MatrixNorm(Norm norm, Complex32[] matrix, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiples two matrices. <c>result = x * y</c>
|
|
/// </summary>
|
|
/// <param name="x">The x matrix.</param>
|
|
/// <param name="xRows">The number of rows in the x matrix.</param>
|
|
/// <param name="xColumns">The number of columns in the x matrix.</param>
|
|
/// <param name="y">The y matrix.</param>
|
|
/// <param name="yRows">The number of rows in the y matrix.</param>
|
|
/// <param name="yColumns">The number of columns in the y matrix.</param>
|
|
/// <param name="result">Where to store the result of the multiplication.</param>
|
|
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
|
|
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
|
|
public void MatrixMultiply(Complex32[] x, int xRows, int xColumns, Complex32[] y, int yRows, int yColumns, Complex32[] result)
|
|
{
|
|
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, Complex32.One, x, xRows, xColumns, y, yRows, yColumns, Complex32.Zero, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
|
|
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
|
|
/// <param name="a">The a matrix.</param>
|
|
/// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
|
|
/// <param name="b">The b matrix</param>
|
|
/// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
|
|
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
|
|
/// <param name="c">The c matrix.</param>
|
|
public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a,
|
|
int aRows, int aColumns, Complex32[] b, int bRows, int bColumns, Complex32 beta, Complex32[] c)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if (b == null)
|
|
{
|
|
throw new ArgumentNullException("b");
|
|
}
|
|
|
|
if (c == null)
|
|
{
|
|
throw new ArgumentNullException("c");
|
|
}
|
|
|
|
var m = transposeA == Transpose.DontTranspose ? aRows : aColumns;
|
|
var n = transposeB == Transpose.DontTranspose ? bColumns : bRows;
|
|
var k = transposeA == Transpose.DontTranspose ? aColumns : aRows;
|
|
|
|
if( c.Length != aRows * bColumns)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
if (aColumns != bRows)
|
|
{
|
|
throw new ArgumentException(Resources.ArgumentMatrixDimensions);
|
|
}
|
|
|
|
SafeNativeMethods.c_matrix_multiply(transposeA, transposeB, m, n, k, ref alpha, a, b, ref beta, c);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the LU factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">An m by n matrix. The matrix is overwritten with the
|
|
/// the LU factorization On exit.</param>
|
|
/// <param name="ipiv">On exit, it contains the pivot indices. The size
|
|
/// of the array must be min(m,n).</param>
|
|
/// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
|
|
public void LUFactor(Complex32[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(Complex32[] a)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(Complex32[] a, int[] ipiv)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of matrix using LU factorization.
|
|
/// </summary>
|
|
/// <param name="a">The N by N matrix to invert. Contains the inverse On exit.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRI LAPACK routines.</remarks>
|
|
public void LUInverse(Complex32[] a, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the inverse of a previously factored matrix.
|
|
/// </summary>
|
|
/// <param name="a">The LU factored N by N matrix. Contains the inverse On exit.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
/// <remarks>This is equivalent to the GETRI LAPACK routine.</remarks>
|
|
public void LUInverseFactored(Complex32[] a, int[] ipiv, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(int columnsOfB, Complex32[] a, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(int columnsOfB, Complex32[] a, int ipiv, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using LU factorization.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRF and GETRS LAPACK routines.</remarks>
|
|
public void LUSolve(Transpose transposeA, int columnsOfB, Complex32[] a, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="ipiv">The pivot indices of <paramref name="a"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the GETRS LAPACK routine.</remarks>
|
|
public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex32[] a, int ipiv, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the Cholesky factorization of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
|
|
/// the Cholesky factorization.</param>
|
|
/// <param name="order">The number of rows or columns in the matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF LAPACK routine.</remarks>
|
|
public void CholeskyFactor(Complex32[] a, int order)
|
|
{
|
|
if (a == null)
|
|
{
|
|
throw new ArgumentNullException("a");
|
|
}
|
|
|
|
if ( order < 1)
|
|
{
|
|
throw new ArgumentException(Properties.Resources.ArgumentMustBePositive, "order");
|
|
}
|
|
|
|
SafeNativeMethods.c_cholesky_factor(order, a);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using Cholesky factorization.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The square, positive definite matrix A.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRF add POTRS LAPACK routines.</remarks>
|
|
public void CholeskySolve(int columnsOfB, Complex32[] a, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously factored A matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="a">The factored A matrix.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <remarks>This is equivalent to the POTRS LAPACK routine.</remarks>
|
|
public void CholeskySolveFactored(int columnsOfB, Complex32[] a, Complex32[] b)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
|
|
public void QRFactor(Complex32[] r, Complex32[] q)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRFactor(Complex32[] r, Complex32[] q, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using QR factorization of A.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
|
|
/// it is overwritten with the R matrix of the QR factorization.</param>
|
|
/// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
|
|
/// QR factorization.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. The array must have a length of at least N,
|
|
/// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
|
|
/// work size value.</param>
|
|
public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously QR factored matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="q">The Q matrix obtained by calling <see cref="QRFactor(Complex32[],Complex32[])"/>.</param>
|
|
/// <param name="r">The R matrix obtained by calling <see cref="QRFactor(Complex32[],Complex32[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void QRSolveFactored(int columnsOfB, Complex32[] q, Complex32[] r, Complex32[] b, Complex32[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SinguarValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
|
|
/// singular vectors.</param>
|
|
/// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
|
|
/// right singular vectors.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
/// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
|
|
public void SingularValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using the singular value decomposition of A.
|
|
/// </summary>
|
|
/// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
|
|
/// <param name="s">The singular values of A in ascending value.</param>
|
|
/// <param name="u">On exit U contains the left singular vectors.</param>
|
|
/// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
/// <param name="work">The work array. For real matrices, the work array should be at least
|
|
/// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
|
|
/// On exit, work[0] contains the optimal work size value.</param>
|
|
public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x, Complex32[] work)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Solves A*X=B for X using a previously SVD decomposed matrix.
|
|
/// </summary>
|
|
/// <param name="columnsOfB">The number of columns of B.</param>
|
|
/// <param name="s">The s values returned by <see cref="SinguarValueDecomposition(bool,Complex32[],Complex32[],Complex32[],Complex32[])"/>.</param>
|
|
/// <param name="u">The left singular vectors returned by <see cref="SinguarValueDecomposition(bool,Complex32[],Complex32[],Complex32[],Complex32[])"/>.</param>
|
|
/// <param name="vt">The right singular vectors returned by <see cref="SinguarValueDecomposition(bool,Complex32[],Complex32[],Complex32[],Complex32[])"/>.</param>
|
|
/// <param name="b">The B matrix.</param>
|
|
/// <param name="x">On exit, the solution matrix.</param>
|
|
public void SvdSolveFactored(int columnsOfB, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|