/// <summary>Computes a matrix-matrix product where one input matrix is symmetric, i.e. C := \alpha*A*B + \beta*C or C := \alpha*B*A +\beta*C.
/// </summary>
/// <param name="m">The number of rows of the matrix C.</param>
/// <param name="n">The number of columns of the matrix C.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The symmetric matrix A supplied column-by-column of dimension (<paramref name="lda" />, ka), where ka is <paramref name="m" /> if to calculate C := \alpha * A*B + \beta*C; otherwise <paramref name="n" />.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb" />,<paramref name="n" />).</param>
/// <param name="beta">The scalar \beta.</param>
/// <param name="c">The matrix C supplied column-by-column of dimension (<paramref name="ldc" />,<paramref name="n" />); input/output.</param>
/// <param name="lda">The leading dimension of <paramref name="a" />, must be at least max(1,<paramref name="m" />) if <paramref name="side" />=left; max(1,n) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b" />, must be at least max(1,<paramref name="m" />).</param>
/// <param name="ldc">The leading dimension of <paramref name="c" />, must be at least max(1,<paramref name="m" />).</param>
/// <param name="side">A value indicating whether to calculate C := \alpha * A*B + \beta*C or C := \alpha * B*A +\beta*C.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
public void zsymm(int m, int n, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c, int lda, int ldb, int ldc, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
if (side == BLAS.Side.Left) // C := \alpha *A*B + \beta * C
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
Complex temp = alpha * b[i + j * ldb];
Complex temp2 = 0.0;
for (int k = 0; k <= i - 1; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * a[k + i * lda];
}
c[i + j * ldc] = alpha * temp2 + temp * a[i + i * lda] + beta * c[i + j * ldc];
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
Complex temp = alpha * b[i + j * ldb];
Complex temp2 = 0.0;
for (int k = i + 1; k < m; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * a[k + i * lda];
}
c[i + j * ldc] = alpha * temp2 + temp * a[i + i * lda] + beta * c[i + j * ldc];
}
}
}
}
else // C := \alpha * B * A + \beta * C
{
for (int j = 0; j < n; j++)
{
Complex temp = alpha * a[j + j * lda];
for (int i = 0; i < m; i++)
{
c[i + j * ldc] = temp * b[i + j * ldb] + beta * c[i + j * ldc];
}
for (int k = 0; k <= j - 1; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * a[k + j * lda];
}
else
{
temp = alpha * a[j + k * lda];
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] = c[i + j * ldc] + temp * b[i + k * ldb];
}
}
for (int k = j + 1; k < n; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * a[j + k * lda];
}
else
{
temp = alpha * a[k + j * lda];
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] = c[i + j * ldc] + temp * b[i + k * ldb];
}
}
}
}
}
/// <summary>Computes a matrix-matrix product where one input matrix is triangular, i.e. B := \alpha * op(A)*B or B:= \alpha *B * op(A), where A is a unit or non-unit upper or lower triangular matrix.
/// </summary>
/// <param name="m">The number of rows of matrix B.</param>
/// <param name="n">The number of columns of matrix B.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The triangular matrix A supplied column-by-column of dimension (<paramref name="lda" />, k), where k is <paramref name="m" /> if to calculate B := \alpha * op(A)*B; <paramref name="n" /> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb" />, <paramref name="n" />).</param>
/// <param name="lda">The leading dimension of <paramref name="a" />, must be at least max(1,<paramref name="m" />) if to calculate B := \alpha * op(A)*B; max(1,<paramref name="n" />) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b" />, must be at least max(1,<paramref name="m" />).</param>
/// <param name="isUnitTriangular">A value indicating whether the matrix A is unit triangular.</param>
/// <param name="side">A value indicating whether to calculate B := \alpha * op(A)*B or B:= \alpha *B * op(A).</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
/// <param name="transpose">A value indicating whether 'op(A)=A' or 'op(A)=A^t'.</param>
public void ztrmm(int m, int n, Complex alpha, Complex[] a, Complex[] b, int lda, int ldb, bool isUnitTriangular = true, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix, BLAS.MatrixTransposeState transpose = BLAS.MatrixTransposeState.NoTranspose)
{
if (side == BLAS.Side.Left)
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B := \alpha * A * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int k = 0; k < m; k++)
{
Complex temp = alpha * b[k + j * ldb];
for (int i = 0; i <= k - 1; i++)
{
b[i + j * ldb] += temp * a[i + k * lda];
}
if (isUnitTriangular == false)
{
temp = temp * a[k + k * lda];
}
b[k + j * ldb] = temp;
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int k = m - 1; k >= 0; k--)
{
Complex temp = alpha * b[k + j * ldb];
b[k + j * ldb] = temp;
if (isUnitTriangular == false)
{
b[k + j * ldb] = b[k + j * ldb] * a[k + k * lda];
}
for (int i = k + 1; i < m; i++)
{
b[i + j * ldb] += temp * a[i + k * lda];
}
}
}
}
}
else // B := \alpha * A' * B or B := \alpha * conjg( A' ) * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
Complex temp = b[i + j * ldb];
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
if (isUnitTriangular == false)
{
temp = temp * a[i + i * lda];
}
for (int k = 0; k <= i - 1; k++)
{
temp += a[k + i * lda] * b[k + j * ldb];
}
}
else
{
if (isUnitTriangular == false)
{
temp = temp * Complex.Conjugate(a[i + i * lda]);
}
for (int k = 0; k <= i - 1; k++)
{
temp += Complex.Conjugate(a[k + i * lda]) * b[k + j * ldb];
}
}
b[i + j * ldb] = alpha * temp;
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
Complex temp = b[i + j * ldb];
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
if (isUnitTriangular == false)
{
temp = temp * a[i + i * lda];
}
for (int k = i + 1; k < m; k++)
{
temp += a[k + i * lda] * b[k + j * ldb];
}
}
else
{
if (isUnitTriangular == false)
{
temp = temp * Complex.Conjugate(a[i + i * lda]);
}
for (int k = i + 1; k < m; k++)
{
temp += Complex.Conjugate(a[k + i * lda]) * b[k + j * ldb];
}
}
b[i + j * ldb] = alpha * temp;
}
}
}
}
}
else
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B:= \alpha * B * A
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = n - 1; j >= 0; j--)
{
Complex temp = alpha;
if (isUnitTriangular == false)
{
temp = temp * a[j + j * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
for (int k = 0; k <= j - 1; k++)
{
temp = alpha * a[k + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
}
}
else
{
for (int j = 0; j < n; j++)
{
Complex temp = alpha;
if (isUnitTriangular == false)
{
temp = temp * a[j + j * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
for (int k = j + 1; k < n; k++)
{
temp = alpha * a[k + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
}
}
}
else // B := \alpha * B * A', B := \alpha * B * \conjg( A' )
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
Complex temp = 0.0;
for (int k = 0; k < n; k++)
{
for (int j = 0; j <= k - 1; j++)
{
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
temp = alpha * a[j + k * lda];
}
else
{
temp = alpha * Complex.Conjugate(a[j + k * lda]);
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
temp = alpha;
if (isUnitTriangular == false)
{
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
temp = temp * a[k + k * lda];
}
else
{
temp = temp * Complex.Conjugate(a[k + k * lda]);
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
}
else
{
Complex temp = 0.0;
for (int k = n - 1; k >= 0; k--)
{
for (int j = k + 1; j < n; j++)
{
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
temp = alpha * a[j + k * lda];
}
else
{
temp = alpha * Complex.Conjugate(a[j + k * lda]);
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
temp = alpha;
if (isUnitTriangular == false)
{
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
temp = temp * a[k + k * lda];
}
else
{
temp = temp * Complex.Conjugate(a[k + k * lda]);
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
}
}
}
}
/// <summary>Computes a matrix-matrix product where one input matrix is triangular, i.e. B := \alpha * op(A)*B or B:= \alpha *B * op(A), where A is a unit or non-unit upper or lower triangular matrix.
/// </summary>
/// <param name="m">The number of rows of matrix B.</param>
/// <param name="n">The number of columns of matrix B.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The triangular matrix A supplied column-by-column of dimension (<paramref name="lda"/>, k), where k is <paramref name="m"/> if to calculate B := \alpha * op(A)*B; <paramref name="n"/> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb"/>, <paramref name="n"/>).</param>
/// <param name="lda">The leading dimension of <paramref name="a"/>, must be at least max(1,<paramref name="m"/>) if to calculate B := \alpha * op(A)*B; max(1,<paramref name="n"/>) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b"/>, must be at least max(1,<paramref name="m"/>).</param>
/// <param name="isUnitTriangular">A value indicating whether the matrix A is unit triangular.</param>
/// <param name="side">A value indicating whether to calculate B := \alpha * op(A)*B or B:= \alpha *B * op(A).</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
/// <param name="transpose">A value indicating whether 'op(A)=A' or 'op(A)=A^t'.</param>
public void dtrmm(int m, int n, double alpha, double[] a, double[] b, int lda, int ldb, bool isUnitTriangular = true, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix, BLAS.MatrixTransposeState transpose = BLAS.MatrixTransposeState.NoTranspose)
{
if (n == 0)
{
return; // nothing to do
}
if (side == BLAS.Side.Left)
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B = \alpha *A*B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int k = 0; k < m; k++)
{
double temp = alpha * b[k + j * ldb];
for (int i = 0; i <= k - 1; i++)
{
b[i + j * ldb] += temp * a[i + k * lda];
}
if (isUnitTriangular == false)
{
temp *= a[k + k * lda];
}
b[k + j * ldb] = temp;
}
}
}
else // lower triangular matrix
{
for (int j = 0; j < n; j++)
{
for (int k = m - 1; k >= 0; k--)
{
double temp = alpha * b[k + j * ldb];
b[k + j * ldb] = temp;
if (isUnitTriangular == false)
{
b[k + j * ldb] *= a[k + k * lda];
}
for (int i = k + 1; i < m; i++)
{
b[i + j * ldb] += temp * a[i + k * lda];
}
}
}
}
}
else // B = \alpha * A' *B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
double temp = b[i + j * ldb];
if (isUnitTriangular == false)
{
temp *= a[i + i * lda];
}
for (int k = 0; k <= i - 1; k++)
{
temp += a[k + i * lda] * b[k + j * ldb];
}
b[i + j * ldb] = alpha * temp;
}
}
}
else // lower triangular matrix
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
double temp = b[i + j * ldb];
if (isUnitTriangular == false)
{
temp *= a[i + i * lda];
}
for (int k = i + 1; k < m; k++)
{
temp += a[k + i * lda] * b[k + j * ldb];
}
b[i + j * ldb] = alpha * temp;
}
}
}
}
}
else // side == BLAS.Side.Right
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B = \alpha * B * A
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = n - 1; j >= 0; j--)
{
double temp = alpha;
if (isUnitTriangular == false)
{
temp *= a[j + j * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
for (int k = 0; k <= j - 1; k++)
{
temp = alpha * a[k + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
}
}
else
{
for (int j = 0; j < n; j++)
{
double temp = alpha;
if (isUnitTriangular == false)
{
temp *= a[j + j * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
for (int k = j + 1; k < n; k++)
{
temp = alpha * a[k + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
}
}
}
else // B = \alpha * B * A'
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int k = 0; k < n; k++)
{
double temp;
for (int j = 0; j < k; j++)
{
temp = alpha * a[j + k * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
temp = alpha;
if (isUnitTriangular == false)
{
temp *= a[k + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
}
else // lower triangular matrix
{
for (int k = n - 1; k >= 0; k--)
{
double temp;
for (int j = k + 1; j < n; j++)
{
temp = alpha * a[j + k * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] += temp * b[i + k * ldb];
}
}
temp = alpha;
if (isUnitTriangular == false)
{
temp *= a[k + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
}
}
}
}
/// <summary>Computes a matrix-matrix product where one input matrix is symmetric, i.e. C := \alpha*A*B + \beta*C or C := \alpha*B*A +\beta*C.
/// </summary>
/// <param name="m">The number of rows of the matrix C.</param>
/// <param name="n">The number of columns of the matrix C.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The symmetric matrix A supplied column-by-column of dimension (<paramref name="lda"/>, ka), where ka is <paramref name="m"/> if to calculate C := \alpha * A*B + \beta*C; otherwise <paramref name="n"/>.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb"/>,<paramref name="n"/>).</param>
/// <param name="beta">The scalar \beta.</param>
/// <param name="c">The matrix C supplied column-by-column of dimension (<paramref name="ldc"/>,<paramref name="n"/>); input/output.</param>
/// <param name="lda">The leading dimension of <paramref name="a"/>, must be at least max(1,<paramref name="m"/>) if <paramref name="side"/>=left; max(1,n) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b"/>, must be at least max(1,<paramref name="m"/>).</param>
/// <param name="ldc">The leading dimension of <paramref name="c"/>, must be at least max(1,<paramref name="m"/>).</param>
/// <param name="side">A value indicating whether to calculate C := \alpha * A*B + \beta*C or C := \alpha * B*A +\beta*C.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
public void dsymm(int m, int n, double alpha, double[] a, double[] b, double beta, double[] c, int lda, int ldb, int ldc, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
if (m == 0 || n == 0 || ((alpha == 0.0) && (beta == 1.0)))
{
return; // nothing to do
}
if (side == BLAS.Side.Left) // C = \alpha *A *B +\beta*C
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
double temp = alpha * b[i + j * lda];
double temp2 = 0.0;
for (int k = 0; k < i; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * a[k + i * lda];
}
c[i + j * ldc] = beta * c[i + j * ldc] + temp * a[i + i * lda] + alpha * temp2;
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
double temp = alpha * b[i + j * ldb];
double temp2 = 0.0;
for (int k = i + 1; k < m; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * a[k + i * lda];
}
c[i + j * ldc] = beta * c[i + j * ldc] + temp * a[i + i * lda] + alpha * temp2;
}
}
}
}
else if (side == BLAS.Side.Right) // C = \alpha*B*A + \beta *C
{
for (int j = 0; j < n; j++)
{
double temp = alpha * a[j + j * lda];
for (int i = 0; i < m; i++)
{
c[i + j * ldc] = beta * c[i + j * ldc] + temp * b[i + j * ldb];
}
for (int k = 0; k < j; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * a[k + j * lda];
}
else
{
temp = alpha * a[j + k * lda];
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] += temp * b[i + k * ldb];
}
}
for (int k = j + 1; k < n; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * a[j + k * lda];
}
else
{
temp = alpha * a[k + j * lda];
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] += temp * b[i + k * ldb];
}
}
}
}
else
{
throw new NotImplementedException(side.ToString());
}
}
/// <summary>Computes a matrix-matrix product where one input matrix is Hermitian, i.e. C := \alpha*A*B + \beta*C or C := \alpha*B*A + \beta*C, where A is a Hermitian matrix.
/// </summary>
/// <param name="m">The number of rows of matrix C.</param>
/// <param name="n">The number of columns of matrix C.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The Hermitian matrix A supplied column-by-column of dimension (<paramref name="ldc"/>, ka), where ka is <paramref name="m"/> if to calculate C := \alpha*A*B + \beta*C; <paramref name="n"/> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb"/>, <paramref name="n"/>).</param>
/// <param name="beta">The scalar \beta.</param>
/// <param name="c">The matrix C supplied column-by-column of dimension (<paramref name="ldc"/>, <paramref name="n"/>).</param>
/// <param name="lda">The leading dimension of <paramref name="a"/>, must be at least max(1,<paramref name="m"/>) if to calculate C := \alpha*A*B + \beta*C; max(1, <paramref name="n"/>) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b"/>, must be at least max(1,<paramref name="m"/>).</param>
/// <param name="ldc">The leading dimension of <paramref name="c"/>, must be at least max(1, <paramref name="m"/>).</param>
/// <param name="side">A value indicating whether to calculate C := \alpha*A*B + \beta*C or C := \alpha*B*A + \beta*C.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
public void zhemm(int m, int n, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c, int lda, int ldb, int ldc, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
if (m == 0 || n == 0 || ((alpha == 0.0) && (beta == 1.0)))
{
return; // nothing to do
}
if (side == BLAS.Side.Left) // C = \alpha *A *B +\beta*C
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
var temp = alpha * b[i + j * lda];
Complex temp2 = 0.0;
for (int k = 0; k <= i - 1; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * Complex.Conjugate(a[k + i * lda]);
}
c[i + j * ldc] = beta * c[i + j * ldc] + a[i + i * lda].Real * temp.Real + Complex.ImaginaryOne * a[i + i * lda].Real * temp.Imaginary + alpha * temp2;
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
Complex temp = alpha * b[i + j * ldb];
Complex temp2 = 0.0;
for (int k = i + 1; k < m; k++)
{
c[k + j * ldc] += temp * a[k + i * lda];
temp2 += b[k + j * ldb] * Complex.Conjugate(a[k + i * lda]);
}
c[i + j * ldc] = beta * c[i + j * ldc] + alpha * temp2 + a[i + i * lda].Real * temp.Real + Complex.ImaginaryOne * (a[i + i * lda].Real * temp.Imaginary);
}
}
}
}
else if (side == BLAS.Side.Right) // C = \alpha*B*A + \beta *C
{
for (int j = 0; j < n; j++)
{
Complex temp = alpha * a[j + j * lda].Real;
for (int i = 0; i < m; i++)
{
c[i + j * ldc] = beta * c[i + j * ldc] + temp * b[i + j * ldb];
}
for (int k = 0; k <= j - 1; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * a[k + j * lda];
}
else
{
temp = alpha * Complex.Conjugate(a[j + k * lda]);
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] += temp * b[i + k * ldb];
}
}
for (int k = j + 1; k < n; k++)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
temp = alpha * Complex.Conjugate(a[j + k * lda]);
}
else
{
temp = alpha * a[k + j * lda];
}
for (int i = 0; i < m; i++)
{
c[i + j * ldc] += temp * b[i + k * ldb];
}
}
}
}
else
{
throw new NotImplementedException(side.ToString());
}
}
/// <summary>Computes a matrix-matrix product where one input matrix is symmetric, i.e. C := \alpha*A*B + \beta*C or C := \alpha*B*A +\beta*C.
/// </summary>
/// <param name="level3">The BLAS level 3 implementation.</param>
/// <param name="m">The number of rows of the matrix C.</param>
/// <param name="n">The number of columns of the matrix C.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The symmetric matrix A supplied column-by-column of dimension (s, ka), where s must be at least max(1,<paramref name="m"/>) and ka is <paramref name="m"/> if to calculate C := \alpha * A*B + \beta*C; s at least max(1,<paramref name="n"/>) and ka is <paramref name="n"/> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="m"/>,<paramref name="n"/>).</param>
/// <param name="beta">The scalar \beta.</param>
/// <param name="c">The matrix C supplied column-by-column of dimension (<paramref name="m"/>,<paramref name="n"/>); input/output.</param>
/// <param name="side">A value indicating whether to calculate C := \alpha * A*B + \beta*C or C := \alpha * B*A +\beta*C.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
public static void dsymm(this ILevel3BLAS level3, int m, int n, double alpha, double[] a, double[] b, double beta, double[] c, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
level3.dsymm(m, n, alpha, a, b, beta, c, (side == BLAS.Side.Left) ? m : n, m, m, side, triangularMatrixType);
}
/// <summary>Solves a triangular matrix equation, i.e. op(A) * X = \alpha * B or X * op(A) = \alpha *B, where A is a unit or non-unit upper or lower triangular matrix.
/// </summary>
/// <param name="level3">The BLAS level 3 implementation.</param>
/// <param name="m">The number of rows of matrix B.</param>
/// <param name="n">The number of column of matrix B.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The triangular matrix A supplied column-by-column of dimension (s, k), where s, k = <paramref name="m"/> if to calculate op(A) * X = \alpha * B; <paramref name="n"/> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="m"/>, <paramref name="n"/>).</param>
/// <param name="isUnitTriangular">A value indicating whether the matrix A is unit triangular.</param>
/// <param name="side">A value indicating whether to calculate op(A) * X = \alpha * B or X * op(A) = \alpha *B.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
/// <param name="transpose">A value indicating whether 'op(A)=A' or 'op(A)=A^t'.</param>
public static void ztrsm(this ILevel3BLAS level3, int m, int n, Complex alpha, Complex[] a, Complex[] b, bool isUnitTriangular = true, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix, BLAS.MatrixTransposeState transpose = BLAS.MatrixTransposeState.NoTranspose)
{
level3.ztrsm(m, n, alpha, a, b, side == BLAS.Side.Left ? m : n, m, isUnitTriangular, side, triangularMatrixType, transpose);
}
/// <summary>Computes a matrix-matrix product where one input matrix is symmetric, i.e. C := \alpha*A*B + \beta*C or C := \alpha*B*A +\beta*C.
/// </summary>
/// <param name="level3">The BLAS level 3 implementation.</param>
/// <param name="m">The number of rows of the matrix C.</param>
/// <param name="n">The number of columns of the matrix C.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The symmetric matrix A supplied column-by-column of dimension (s, ka), where s must be at least max(1,<paramref name="m"/>) and ka is <paramref name="m"/> if to calculate C := \alpha * A*B + \beta*C; otherwise s at least max(1,<paramref name="n"/>) and ka = <paramref name="n"/>.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="m"/>,<paramref name="n"/>).</param>
/// <param name="beta">The scalar \beta.</param>
/// <param name="c">The matrix C supplied column-by-column of dimension (<paramref name="m"/>,<paramref name="n"/>); input/output.</param>
/// <param name="side">A value indicating whether to calculate C := \alpha * A*B + \beta*C or C := \alpha * B*A +\beta*C.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
public static void zsymm(this ILevel3BLAS level3, int m, int n, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
level3.zsymm(m, n, alpha, a, b, beta, c, side == BLAS.Side.Left ? m : n, m, m, side, triangularMatrixType);
}
/// <summary>Solves a triangular matrix equation, i.e. op(A) * X = \alpha * B or X * op(A) = \alpha *B, where A is a unit or non-unit upper or lower triangular matrix.
/// </summary>
/// <param name="m">The number of rows of matrix B.</param>
/// <param name="n">The number of column of matrix B.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The triangular matrix A supplied column-by-column of dimension (<paramref name="lda"/>, k), where k is <paramref name="m"/> if to calculate op(A) * X = \alpha * B; <paramref name="n"/> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb"/>, <paramref name="n"/>).</param>
/// <param name="lda">The leading dimension of <paramref name="a"/>, must be at least max(1,<paramref name="m"/>) if to calculate op(A) * X = \alpha * B; max(1,<paramref name="n"/>) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b"/>, must be at least max(1,<paramref name="m"/>).</param>
/// <param name="isUnitTriangular">A value indicating whether the matrix A is unit triangular.</param>
/// <param name="side">A value indicating whether to calculate op(A) * X = \alpha * B or X * op(A) = \alpha *B.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
/// <param name="transpose">A value indicating whether 'op(A)=A' or 'op(A)=A^t'.</param>
public void dtrsm(int m, int n, double alpha, double[] a, double[] b, int lda, int ldb, bool isUnitTriangular = true, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix, BLAS.MatrixTransposeState transpose = BLAS.MatrixTransposeState.NoTranspose)
{
if (n == 0)
{
return; // nothing to do
}
if (side == BLAS.Side.Left)
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // A * X = \alpha * B, i.e. X [=:B] = \alpha * Inv(A) * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = m - 1; k >= 0; k--)
{
if (b[k + j * ldb] != 0.0)
{
if (isUnitTriangular == false)
{
b[k + j * ldb] /= a[k + k * lda];
}
for (int i = 0; i <= k - 1; i++)
{
b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
}
}
}
}
}
else // lower triangular matrix
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = 0; k < m; k++)
{
if (isUnitTriangular == false)
{
b[k + j * ldb] /= a[k + k * lda];
}
for (int i = k + 1; i < m; i++)
{
b[i + j * ldb] -= b[k + j * ldb] * a[i + k * lda];
}
}
}
}
}
else // A' * X = \alpha * B, i.e. X [=: B] = \alpha * inv(A') * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
double temp = alpha * b[i + j * ldb];
for (int k = 0; k <= i - 1; k++)
{
temp -= a[k + i * lda] * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp /= a[i + i * lda];
}
b[i + j * ldb] = temp;
}
}
}
else // lower triangular matrix
{
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
double temp = alpha * b[i + j * ldb];
for (int k = i + 1; k < m; k++)
{
temp -= a[k + i * lda] * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp /= a[i + i * lda];
}
b[i + j * ldb] = temp;
}
}
}
}
}
else // side == BLAS.Side.Right
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // X * A = \alpha * B, i.e. X [=:B] = \alpha * B * Inv(A)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = 0; k <= j - 1; k++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
}
}
if (isUnitTriangular == false)
{
double temp = 1.0 / a[j + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
}
}
}
else // lower triangular matrix
{
for (int j = n - 1; j >= 0; j--)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = j + 1; k < n; k++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] -= a[k + j * lda] * b[i + k * ldb];
}
}
if (isUnitTriangular == false)
{
double temp = 1.0 / a[j + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
}
}
}
}
else // X * A' = \alpha * B, i.e. X [=:B] = \alpha * B * Inv(A')
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int k = n - 1; k >= 0; k--)
{
if (isUnitTriangular == false)
{
double temp = 1.0 / a[k + k * lda];
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
for (int j = 0; j <= k - 1; j++)
{
double temp = a[j + k * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] -= temp * b[i + k * ldb];
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = alpha * b[i + k * ldb];
}
}
}
else // lower triangular matrix
{
for (int k = 0; k < n; k++)
{
if (isUnitTriangular == false)
{
double temp = 1.0 / a[k + k * lda];
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
for (int j = k + 1; j < n; j++)
{
double temp = a[j + k * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] -= temp * b[i + k * ldb];
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = alpha * b[i + k * ldb];
}
}
}
}
}
}
/// <summary>Solves a triangular matrix equation, i.e. op(A) * X = \alpha * B or X * op(A) = \alpha *B, where A is a unit or non-unit upper or lower triangular matrix.
/// </summary>
/// <param name="m">The number of rows of matrix B.</param>
/// <param name="n">The number of column of matrix B.</param>
/// <param name="alpha">The scalar \alpha.</param>
/// <param name="a">The triangular matrix A supplied column-by-column of dimension (<paramref name="lda" />, k), where k is <paramref name="m" /> if to calculate op(A) * X = \alpha * B; <paramref name="n" /> otherwise.</param>
/// <param name="b">The matrix B supplied column-by-column of dimension (<paramref name="ldb" />, <paramref name="n" />).</param>
/// <param name="lda">The leading dimension of <paramref name="a" />, must be at least max(1,<paramref name="m" />) if to calculate op(A) * X = \alpha * B; max(1,<paramref name="n" />) otherwise.</param>
/// <param name="ldb">The leading dimension of <paramref name="b" />, must be at least max(1,<paramref name="m" />).</param>
/// <param name="isUnitTriangular">A value indicating whether the matrix A is unit triangular.</param>
/// <param name="side">A value indicating whether to calculate op(A) * X = \alpha * B or X * op(A) = \alpha *B.</param>
/// <param name="triangularMatrixType">A value whether matrix A is in its upper or lower triangular representation.</param>
/// <param name="transpose">A value indicating whether 'op(A)=A' or 'op(A)=A^t'.</param>
public void ztrsm(int m, int n, Complex alpha, Complex[] a, Complex[] b, int lda, int ldb, bool isUnitTriangular = true, BLAS.Side side = BLAS.Side.Left, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.UpperTriangularMatrix, BLAS.MatrixTransposeState transpose = BLAS.MatrixTransposeState.NoTranspose)
{
if (side == BLAS.Side.Left)
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B := \alpha * Inv(A) * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] *= alpha;
}
for (int k = m - 1; k >= 0; k--)
{
if (isUnitTriangular == false)
{
b[k + j * ldb] = b[k + j * ldb] / a[k + k * lda];
}
for (int i = 0; i <= k - 1; i++)
{
b[i + j * ldb] += -b[k + j * ldb] * a[i + k * lda];
}
}
}
}
else
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] *= alpha;
}
for (int k = 0; k < m; k++)
{
if (isUnitTriangular == false)
{
b[k + j * ldb] = b[k + j * ldb] / a[k + k * lda];
}
for (int i = k + 1; i < m; i++)
{
b[i + j * ldb] += -b[k + j * ldb] * a[i + k * lda];
}
}
}
}
}
else // B:= \alpha * Inv(A') * B or B := \alpha * Inv( Conj(A') ) * B
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
Complex temp = 0.0;
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
temp = alpha * b[i + j * ldb];
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
for (int k = 0; k <= i - 1; k++)
{
temp += -a[k + i * lda] * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp = temp / a[i + i * lda];
}
}
else
{
for (int k = 0; k <= i - 1; k++)
{
temp += -Complex.Conjugate(a[k + i * lda]) * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp = temp / Complex.Conjugate(a[i + i * lda]);
}
}
b[i + j * ldb] = temp;
}
}
}
else
{
Complex temp = 0.0;
for (int j = 0; j < n; j++)
{
for (int i = m - 1; i >= 0; i--)
{
temp = alpha * b[i + j * ldb];
if (transpose == BLAS.MatrixTransposeState.Transpose)
{
for (int k = i + 1; k < m; k++)
{
temp += -a[k + i * lda] * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp = temp / a[i + i * lda];
}
}
else
{
for (int k = i + 1; k < m; k++)
{
temp = temp - Complex.Conjugate(a[k + i * lda]) * b[k + j * ldb];
}
if (isUnitTriangular == false)
{
temp = temp / Complex.Conjugate(a[i + i * lda]);
}
}
b[i + j * ldb] = temp;
}
}
}
}
}
else
{
if (transpose == BLAS.MatrixTransposeState.NoTranspose) // B := \alpha * B * Inv(A)
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = 0; k <= j - 1; k++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = b[i + j * ldb] - a[k + j * lda] * b[i + k * ldb];
}
}
if (isUnitTriangular == false)
{
Complex temp = 1.0 / a[j + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
}
}
}
else
{
for (int j = n - 1; j >= 0; j--)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = alpha * b[i + j * ldb];
}
for (int k = j + 1; k < n; k++)
{
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = b[i + j * ldb] - a[k + j * lda] * b[i + k * ldb];
}
}
if (isUnitTriangular == false)
{
Complex temp = 1.0 / a[j + j * lda];
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = temp * b[i + j * ldb];
}
}
}
}
}
else // B := \alpha * B * Inv(A') or B:=\alpha * B *Inv( Conj(A') )
{
if (triangularMatrixType == BLAS.TriangularMatrixType.UpperTriangularMatrix)
{
Complex temp = 0.0;
for (int k = n - 1; k >= 0; k--)
{
if (isUnitTriangular == false)
{
if (transpose == BLAS.MatrixTransposeState.Hermite)
{
temp = 1.0 / Complex.Conjugate(a[k + k * lda]);
}
else
{
temp = 1.0 / a[k + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
for (int j = 0; j <= k - 1; j++)
{
if (transpose == BLAS.MatrixTransposeState.Hermite)
{
temp = Complex.Conjugate(a[j + k * lda]);
}
else
{
temp = a[j + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = b[i + j * ldb] - temp * b[i + k * ldb];
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = alpha * b[i + k * ldb];
}
}
}
else
{
Complex temp = 0.0;
for (int k = 0; k < n; k++)
{
if (isUnitTriangular == false)
{
if (transpose == BLAS.MatrixTransposeState.Hermite)
{
temp = 1.0 / Complex.Conjugate(a[k + k * lda]);
}
else
{
temp = 1.0 / a[k + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = temp * b[i + k * ldb];
}
}
for (int j = k + 1; j < n; j++)
{
if (transpose == BLAS.MatrixTransposeState.Hermite)
{
temp = Complex.Conjugate(a[j + k * lda]);
}
else
{
temp = a[j + k * lda];
}
for (int i = 0; i < m; i++)
{
b[i + j * ldb] = b[i + j * ldb] - temp * b[i + k * ldb];
}
}
for (int i = 0; i < m; i++)
{
b[i + k * ldb] = alpha * b[i + k * ldb];
}
}
}
}
}
}
