/// <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]; } } } } } }