ManagedLinearAlgebraOperationsOfSingle.SymmetricRankUpdate Method

Definition

Namespace: Numerics.NET.LinearAlgebra.Implementation
Assembly: Numerics.NET.SinglePrecision (in Numerics.NET.SinglePrecision.dll) Version: 9.0.3

Overload List

SymmetricRankUpdate(MatrixTriangle, Int32, T, ArraySlice<T>, Array2D<T>)	Performs the symmetric rank 1 operation A := alphaxx**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix.
SymmetricRankUpdate(MatrixTriangle, Int32, T, ArraySlice<T>, ArraySlice<T>, Array2D<T>)	Performs the symmetric rank 2 operation A := alphaxy*T + alphayx*T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.
SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)	Performs the symmetric rank 1 operation A := alphaxx**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, Array2D<T>, T, Array2D<T>)	Performs one of the symmetric rank k operations C := alphaAA^T + betaC, or C := alphaA^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<T>, Array2D<Complex<T>>, Complex<T>, Array2D<Complex<T>>)	Performs one of the symmetric rank k operations C := alphaAA^T + betaC, or C := alphaA^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<T>, ReadOnlySpan2D<Complex<T>>, Complex<T>, Span2D<Complex<T>>)	Performs one of the symmetric rank k operations C := alphaAA^T + betaC, or C := alphaA^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, Array2D<T>, Array2D<T>, T, Array2D<T>)	Performs one of the symmetric rank 2k operations C := alphaAB^T + alphaBA^T + betaC, or C := alphaA^TB + alphaB^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<T>, Array2D<Complex<T>>, Array2D<Complex<T>>, Complex<T>, Array2D<Complex<T>>)	Performs one of the symmetric rank 2k operations C := alphaAB^T + alphaBA^T + betaC, or C := alphaA^TB + alphaB^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<T>, ReadOnlySpan2D<Complex<T>>, ReadOnlySpan2D<Complex<T>>, Complex<T>, Span2D<Complex<T>>)	Performs one of the symmetric rank 2k operations C := alphaAB^T + alphaBA^T + betaC, or C := alphaA^TB + alphaB^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)	Performs the symmetric rank 2 operation A := alphaxy*T + alphayx*T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)	Performs one of the symmetric rank k operations C := alphaAA^T + betaC, or C := alphaA^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)	Performs one of the symmetric rank k operations C := alphaAA^T + betaC, or C := alphaA^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)	Performs one of the symmetric rank 2k operations C := alphaAB^T + alphaBA^T + betaC, or C := alphaA^TB + alphaB^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)	Performs one of the symmetric rank 2k operations C := alphaAB^T + alphaBA^T + betaC, or C := alphaA^TB + alphaB^TA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.

SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)

Performs the symmetric rank 1 operation A := alpha*x*x**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix.

public override void SymmetricRankUpdate(
	MatrixTriangle storedTriangle,
	int n,
	float alpha,
	ReadOnlySpan<float> x,
	int incx,
	Span<float> a,
	int lda
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	storedTriangle As MatrixTriangle,
	n As Integer,
	alpha As Single,
	x As ReadOnlySpan(Of Single),
	incx As Integer,
	a As Span(Of Single),
	lda As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle storedTriangle, 
	int n, 
	float alpha, 
	ReadOnlySpan<float> x, 
	int incx, 
	Span<float> a, 
	int lda
) override

abstract SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        n : int * 
        alpha : float32 * 
        x : ReadOnlySpan<float32> * 
        incx : int * 
        a : Span<float32> * 
        lda : int -> unit 
override SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        n : int * 
        alpha : float32 * 
        x : ReadOnlySpan<float32> * 
        incx : int * 
        a : Span<float32> * 
        lda : int -> unit

Parameters

storedTriangle MatrixTriangle

Specifies whether the matrix is an upper or lower triangular matrix.

n Int32

             On entry, N specifies the order of the matrix A.
             N must be at least zero.

alpha Single

            ALPHA is DOUBLE PRECISION.
             On entry, ALPHA specifies the scalar alpha.

x ReadOnlySpan<Single>

            X is DOUBLE PRECISION array of dimension at least
             ( 1 + ( n - 1 )*abs( INCX ) ).
             Before entry, the incremented array X must contain the n
             element vector x.

incx Int32

             On entry, INCX specifies the increment for the elements of
             X. INCX must not be zero.

a Span<Single>

            A is DOUBLE PRECISION array of DIMENSION ( LDA, n ).
             Before entry with  UPLO = 'U' or 'u', the leading n by n
             upper triangular part of the array A must contain the upper
             triangular part of the symmetric matrix and the strictly
             lower triangular part of A is not referenced. On exit, the
             upper triangular part of the array A is overwritten by the
             upper triangular part of the updated matrix.
             Before entry with UPLO = 'L' or 'l', the leading n by n
             lower triangular part of the array A must contain the lower
             triangular part of the symmetric matrix and the strictly
             upper triangular part of A is not referenced. On exit, the
             lower triangular part of the array A is overwritten by the
             lower triangular part of the updated matrix.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in the calling (sub) program. LDA must be at least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, Int32, T, ReadOnlySpan<T>, Int32, Span<T>, Int32)

Remarks

Further Details:

            Level 2 LinearAlgebra routine.
            -- Written on 22-October-1986.
               Jack Dongarra, Argonne National Lab.
               Jeremy Du Croz, Nag Central Office.
               Sven Hammarling, Nag Central Office.
               Richard Hanson, Sandia National Labs.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)

Performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.

public override void SymmetricRankUpdate(
	MatrixTriangle storedTriangle,
	int n,
	float alpha,
	ReadOnlySpan<float> x,
	int incx,
	ReadOnlySpan<float> y,
	int incy,
	Span<float> a,
	int lda
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	storedTriangle As MatrixTriangle,
	n As Integer,
	alpha As Single,
	x As ReadOnlySpan(Of Single),
	incx As Integer,
	y As ReadOnlySpan(Of Single),
	incy As Integer,
	a As Span(Of Single),
	lda As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle storedTriangle, 
	int n, 
	float alpha, 
	ReadOnlySpan<float> x, 
	int incx, 
	ReadOnlySpan<float> y, 
	int incy, 
	Span<float> a, 
	int lda
) override

abstract SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        n : int * 
        alpha : float32 * 
        x : ReadOnlySpan<float32> * 
        incx : int * 
        y : ReadOnlySpan<float32> * 
        incy : int * 
        a : Span<float32> * 
        lda : int -> unit 
override SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        n : int * 
        alpha : float32 * 
        x : ReadOnlySpan<float32> * 
        incx : int * 
        y : ReadOnlySpan<float32> * 
        incy : int * 
        a : Span<float32> * 
        lda : int -> unit

Parameters

storedTriangle MatrixTriangle

Specifies whether the matrix is an upper or lower triangular matrix.

n Int32

             On entry, N specifies the order of the matrix A.
             N must be at least zero.

alpha Single

            ALPHA is DOUBLE PRECISION.
             On entry, ALPHA specifies the scalar alpha.

x ReadOnlySpan<Single>

            X is DOUBLE PRECISION array of dimension at least
             ( 1 + ( n - 1 )*abs( INCX ) ).
             Before entry, the incremented array X must contain the n
             element vector x.

incx Int32

             On entry, INCX specifies the increment for the elements of
             X. INCX must not be zero.

y ReadOnlySpan<Single>

            Y is DOUBLE PRECISION array of dimension at least
             ( 1 + ( n - 1 )*abs( INCY ) ).
             Before entry, the incremented array Y must contain the n
             element vector y.

incy Int32

             On entry, INCY specifies the increment for the elements of
             Y. INCY must not be zero.

a Span<Single>

            A is DOUBLE PRECISION array of DIMENSION ( LDA, n ).
             Before entry with  UPLO = 'U' or 'u', the leading n by n
             upper triangular part of the array A must contain the upper
             triangular part of the symmetric matrix and the strictly
             lower triangular part of A is not referenced. On exit, the
             upper triangular part of the array A is overwritten by the
             upper triangular part of the updated matrix.
             Before entry with UPLO = 'L' or 'l', the leading n by n
             lower triangular part of the array A must contain the lower
             triangular part of the symmetric matrix and the strictly
             upper triangular part of A is not referenced. On exit, the
             lower triangular part of the array A is overwritten by the
             lower triangular part of the updated matrix.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in the calling (sub) program. LDA must be at least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, Int32, T, ReadOnlySpan<T>, Int32, ReadOnlySpan<T>, Int32, Span<T>, Int32)

Remarks

Further Details:

            Level 2 LinearAlgebra routine.
            -- Written on 22-October-1986.
               Jack Dongarra, Argonne National Lab.
               Jeremy Du Croz, Nag Central Office.
               Sven Hammarling, Nag Central Office.
               Richard Hanson, Sandia National Labs.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)

Performs one of the symmetric rank k operations C := alpha*A*A^T + beta*C, or C := alpha*A^T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.

public override void SymmetricRankUpdate(
	MatrixTriangle uplo,
	TransposeOperation trans,
	int n,
	int k,
	Complex<float> alpha,
	ReadOnlySpan<Complex<float>> a,
	int lda,
	Complex<float> beta,
	Span<Complex<float>> c,
	int ldc
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	uplo As MatrixTriangle,
	trans As TransposeOperation,
	n As Integer,
	k As Integer,
	alpha As Complex(Of Single),
	a As ReadOnlySpan(Of Complex(Of Single)),
	lda As Integer,
	beta As Complex(Of Single),
	c As Span(Of Complex(Of Single)),
	ldc As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle uplo, 
	TransposeOperation trans, 
	int n, 
	int k, 
	Complex<float> alpha, 
	ReadOnlySpan<Complex<float>> a, 
	int lda, 
	Complex<float> beta, 
	Span<Complex<float>> c, 
	int ldc
) override

abstract SymmetricRankUpdate : 
        uplo : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : Complex<float32> * 
        a : ReadOnlySpan<Complex<float32>> * 
        lda : int * 
        beta : Complex<float32> * 
        c : Span<Complex<float32>> * 
        ldc : int -> unit 
override SymmetricRankUpdate : 
        uplo : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : Complex<float32> * 
        a : ReadOnlySpan<Complex<float32>> * 
        lda : int * 
        beta : Complex<float32> * 
        c : Span<Complex<float32>> * 
        ldc : int -> unit

Parameters

uplo MatrixTriangle

             On  entry,   UPLO  specifies  whether  the  upper  or  lower
             triangular  part  of the  array  C  is to be  referenced  as
             follows:
                UPLO = 'U' or 'u'   Only the  upper triangular part of  C
                                    is to be referenced.
                UPLO = 'L' or 'l'   Only the  lower triangular part of  C
                                    is to be referenced.

trans TransposeOperation

             On entry,  TRANS  specifies the operation to be performed as
             follows:
                TRANS = 'N' or 'n'   C := alpha*A*A^T + beta*C.
                TRANS = 'T' or 't'   C := alpha*A^T*A + beta*C.

n Int32

             On entry,  N specifies the order of the matrix C.  N must be
             at least zero.

k Int32

             On entry with  TRANS = 'N' or 'n',  K  specifies  the number
             of  columns   of  the   matrix   A,   and  on   entry   with
             TRANS = 'T' or 't',  K  specifies  the number of rows of the
             matrix A.  K must be at least zero.

alpha Complex<Single>

             On entry, ALPHA specifies the scalar alpha.

a ReadOnlySpan<Complex<Single>>

            A is complex array of DIMENSION ( LDA, ka ), where ka is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  A  must contain the matrix  A,  otherwise
             the leading  k by n  part of the array  A  must contain  the
             matrix A.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDA must be at least  max( 1, n ), otherwise  LDA must
             be at least  max( 1, k ).

beta Complex<Single>

             On entry, BETA specifies the scalar beta.

c Span<Complex<Single>>

            C is complex array of DIMENSION ( LDC, n ).
             Before entry  with  UPLO = 'U' or 'u',  the leading  n by n
             upper triangular part of the array C must contain the upper
             triangular part  of the  symmetric matrix  and the strictly
             lower triangular part of C is not referenced.  On exit, the
             upper triangular part of the array  C is overwritten by the
             upper triangular part of the updated matrix.
             Before entry  with  UPLO = 'L' or 'l',  the leading  n by n
             lower triangular part of the array C must contain the lower
             triangular part  of the  symmetric matrix  and the strictly
             upper triangular part of C is not referenced.  On exit, the
             lower triangular part of the array  C is overwritten by the
             lower triangular part of the updated matrix.

ldc Int32

             On entry, LDC specifies the first dimension of C as declared
             in  the  calling  (sub)  program.   LDC  must  be  at  least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, ReadOnlySpan<T>, Int32, T, Span<T>, Int32)

Remarks

Further Details:

            Level 3 LinearAlgebra routine.
            -- Written on 8-February-1989.
               Jack Dongarra, Argonne National Laboratory.
               Iain Duff, AERE Harwell.
               Jeremy Du Croz, Numerical Algorithms Group Ltd.
               Sven Hammarling, Numerical Algorithms Group Ltd.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)

public override void SymmetricRankUpdate(
	MatrixTriangle storedTriangle,
	TransposeOperation trans,
	int n,
	int k,
	float alpha,
	ReadOnlySpan<float> a,
	int lda,
	float beta,
	Span<float> c,
	int ldc
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	storedTriangle As MatrixTriangle,
	trans As TransposeOperation,
	n As Integer,
	k As Integer,
	alpha As Single,
	a As ReadOnlySpan(Of Single),
	lda As Integer,
	beta As Single,
	c As Span(Of Single),
	ldc As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle storedTriangle, 
	TransposeOperation trans, 
	int n, 
	int k, 
	float alpha, 
	ReadOnlySpan<float> a, 
	int lda, 
	float beta, 
	Span<float> c, 
	int ldc
) override

abstract SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : float32 * 
        a : ReadOnlySpan<float32> * 
        lda : int * 
        beta : float32 * 
        c : Span<float32> * 
        ldc : int -> unit 
override SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : float32 * 
        a : ReadOnlySpan<float32> * 
        lda : int * 
        beta : float32 * 
        c : Span<float32> * 
        ldc : int -> unit

Parameters

storedTriangle MatrixTriangle

Specifies whether the elements of the matrix c are stored in the upper or lower triangular part.

trans TransposeOperation

             On entry,  TRANS  specifies the operation to be performed as
             follows:
                TRANS = 'N' or 'n'   C := alpha*A*A^T + beta*C.
                TRANS = 'T' or 't'   C := alpha*A^T*A + beta*C.
                TRANS = 'C' or 'c'   C := alpha*A^T*A + beta*C.

n Int32

             On entry,  N specifies the order of the matrix C.  N must be
             at least zero.

k Int32

             On entry with  TRANS = 'N' or 'n',  K  specifies  the number
             of  columns   of  the   matrix   A,   and  on   entry   with
             TRANS = 'T' or 't' or 'C' or 'c',  K  specifies  the  number
             of rows of the matrix  A.  K must be at least zero.

alpha Single

            ALPHA is DOUBLE PRECISION.
             On entry, ALPHA specifies the scalar alpha.

a ReadOnlySpan<Single>

            A is DOUBLE PRECISION array of DIMENSION ( LDA, ka ), where ka is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  A  must contain the matrix  A,  otherwise
             the leading  k by n  part of the array  A  must contain  the
             matrix A.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDA must be at least  max( 1, n ), otherwise  LDA must
             be at least  max( 1, k ).

beta Single

            BETA is DOUBLE PRECISION.
             On entry, BETA specifies the scalar beta.

c Span<Single>

            C is DOUBLE PRECISION array of DIMENSION ( LDC, n ).
             Before entry  with  UPLO = 'U' or 'u',  the leading  n by n
             upper triangular part of the array C must contain the upper
             triangular part  of the  symmetric matrix  and the strictly
             lower triangular part of C is not referenced.  On exit, the
             upper triangular part of the array  C is overwritten by the
             upper triangular part of the updated matrix.
             Before entry  with  UPLO = 'L' or 'l',  the leading  n by n
             lower triangular part of the array C must contain the lower
             triangular part  of the  symmetric matrix  and the strictly
             upper triangular part of C is not referenced.  On exit, the
             lower triangular part of the array  C is overwritten by the
             lower triangular part of the updated matrix.

ldc Int32

             On entry, LDC specifies the first dimension of C as declared
             in  the  calling  (sub)  program.   LDC  must  be  at  least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, ReadOnlySpan<T>, Int32, T, Span<T>, Int32)

Remarks

Further Details:

            Level 3 LinearAlgebra routine.
            -- Written on 8-February-1989.
               Jack Dongarra, Argonne National Laboratory.
               Iain Duff, AERE Harwell.
               Jeremy Du Croz, Numerical Algorithms Group Ltd.
               Sven Hammarling, Numerical Algorithms Group Ltd.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)

Performs one of the symmetric rank 2k operations C := alpha*A*B^T + alpha*B*A^T + beta*C, or C := alpha*A^T*B + alpha*B^T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.

public override void SymmetricRankUpdate(
	MatrixTriangle uplo,
	TransposeOperation trans,
	int n,
	int k,
	Complex<float> alpha,
	ReadOnlySpan<Complex<float>> a,
	int lda,
	ReadOnlySpan<Complex<float>> b,
	int ldb,
	Complex<float> beta,
	Span<Complex<float>> c,
	int ldc
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	uplo As MatrixTriangle,
	trans As TransposeOperation,
	n As Integer,
	k As Integer,
	alpha As Complex(Of Single),
	a As ReadOnlySpan(Of Complex(Of Single)),
	lda As Integer,
	b As ReadOnlySpan(Of Complex(Of Single)),
	ldb As Integer,
	beta As Complex(Of Single),
	c As Span(Of Complex(Of Single)),
	ldc As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle uplo, 
	TransposeOperation trans, 
	int n, 
	int k, 
	Complex<float> alpha, 
	ReadOnlySpan<Complex<float>> a, 
	int lda, 
	ReadOnlySpan<Complex<float>> b, 
	int ldb, 
	Complex<float> beta, 
	Span<Complex<float>> c, 
	int ldc
) override

abstract SymmetricRankUpdate : 
        uplo : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : Complex<float32> * 
        a : ReadOnlySpan<Complex<float32>> * 
        lda : int * 
        b : ReadOnlySpan<Complex<float32>> * 
        ldb : int * 
        beta : Complex<float32> * 
        c : Span<Complex<float32>> * 
        ldc : int -> unit 
override SymmetricRankUpdate : 
        uplo : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : Complex<float32> * 
        a : ReadOnlySpan<Complex<float32>> * 
        lda : int * 
        b : ReadOnlySpan<Complex<float32>> * 
        ldb : int * 
        beta : Complex<float32> * 
        c : Span<Complex<float32>> * 
        ldc : int -> unit

Parameters

uplo MatrixTriangle

             On  entry,   UPLO  specifies  whether  the  upper  or  lower
             triangular  part  of the  array  C  is to be  referenced  as
             follows:
                UPLO = 'U' or 'u'   Only the  upper triangular part of  C
                                    is to be referenced.
                UPLO = 'L' or 'l'   Only the  lower triangular part of  C
                                    is to be referenced.

trans TransposeOperation

             On entry,  TRANS  specifies the operation to be performed as
             follows:
                TRANS = 'N' or 'n'    C := alpha*A*B^T + alpha*B*A^T +
                                           beta*C.
                TRANS = 'T' or 't'    C := alpha*A^T*B + alpha*B^T*A +
                                           beta*C.

n Int32

             On entry,  N specifies the order of the matrix C.  N must be
             at least zero.

k Int32

             On entry with  TRANS = 'N' or 'n',  K  specifies  the number
             of  columns  of the  matrices  A and B,  and on  entry  with
             TRANS = 'T' or 't',  K  specifies  the number of rows of the
             matrices  A and B.  K must be at least zero.

alpha Complex<Single>

             On entry, ALPHA specifies the scalar alpha.

a ReadOnlySpan<Complex<Single>>

            A is complex array of DIMENSION ( LDA, ka ), where ka is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  A  must contain the matrix  A,  otherwise
             the leading  k by n  part of the array  A  must contain  the
             matrix A.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDA must be at least  max( 1, n ), otherwise  LDA must
             be at least  max( 1, k ).

b ReadOnlySpan<Complex<Single>>

            B is complex array of DIMENSION ( LDB, kb ), where kb is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  B  must contain the matrix  B,  otherwise
             the leading  k by n  part of the array  B  must contain  the
             matrix B.

ldb Int32

             On entry, LDB specifies the first dimension of B as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDB must be at least  max( 1, n ), otherwise  LDB must
             be at least  max( 1, k ).

beta Complex<Single>

             On entry, BETA specifies the scalar beta.

c Span<Complex<Single>>

            C is complex array of DIMENSION ( LDC, n ).
             Before entry  with  UPLO = 'U' or 'u',  the leading  n by n
             upper triangular part of the array C must contain the upper
             triangular part  of the  symmetric matrix  and the strictly
             lower triangular part of C is not referenced.  On exit, the
             upper triangular part of the array  C is overwritten by the
             upper triangular part of the updated matrix.
             Before entry  with  UPLO = 'L' or 'l',  the leading  n by n
             lower triangular part of the array C must contain the lower
             triangular part  of the  symmetric matrix  and the strictly
             upper triangular part of C is not referenced.  On exit, the
             lower triangular part of the array  C is overwritten by the
             lower triangular part of the updated matrix.

ldc Int32

             On entry, LDC specifies the first dimension of C as declared
             in  the  calling  (sub)  program.   LDC  must  be  at  least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, ReadOnlySpan<T>, Int32, ReadOnlySpan<T>, Int32, T, Span<T>, Int32)

Remarks

Further Details:

            Level 3 LinearAlgebra routine.
            -- Written on 8-February-1989.
               Jack Dongarra, Argonne National Laboratory.
               Iain Duff, AERE Harwell.
               Jeremy Du Croz, Numerical Algorithms Group Ltd.
               Sven Hammarling, Numerical Algorithms Group Ltd.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)

public override void SymmetricRankUpdate(
	MatrixTriangle storedTriangle,
	TransposeOperation trans,
	int n,
	int k,
	float alpha,
	ReadOnlySpan<float> a,
	int lda,
	ReadOnlySpan<float> b,
	int ldb,
	float beta,
	Span<float> c,
	int ldc
)

Visual Basic

Public Overrides Sub SymmetricRankUpdate ( 
	storedTriangle As MatrixTriangle,
	trans As TransposeOperation,
	n As Integer,
	k As Integer,
	alpha As Single,
	a As ReadOnlySpan(Of Single),
	lda As Integer,
	b As ReadOnlySpan(Of Single),
	ldb As Integer,
	beta As Single,
	c As Span(Of Single),
	ldc As Integer
)

C++/CLI

public:
virtual void SymmetricRankUpdate(
	MatrixTriangle storedTriangle, 
	TransposeOperation trans, 
	int n, 
	int k, 
	float alpha, 
	ReadOnlySpan<float> a, 
	int lda, 
	ReadOnlySpan<float> b, 
	int ldb, 
	float beta, 
	Span<float> c, 
	int ldc
) override

abstract SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : float32 * 
        a : ReadOnlySpan<float32> * 
        lda : int * 
        b : ReadOnlySpan<float32> * 
        ldb : int * 
        beta : float32 * 
        c : Span<float32> * 
        ldc : int -> unit 
override SymmetricRankUpdate : 
        storedTriangle : MatrixTriangle * 
        trans : TransposeOperation * 
        n : int * 
        k : int * 
        alpha : float32 * 
        a : ReadOnlySpan<float32> * 
        lda : int * 
        b : ReadOnlySpan<float32> * 
        ldb : int * 
        beta : float32 * 
        c : Span<float32> * 
        ldc : int -> unit

Parameters

storedTriangle MatrixTriangle

Specifies whether the elements of the matrix a are stored in the upper or lower triangular part.

trans TransposeOperation

             On entry,  TRANS  specifies the operation to be performed as
             follows:
                TRANS = 'N' or 'n'   C := alpha*A*B^T + alpha*B*A^T +
                                          beta*C.
                TRANS = 'T' or 't'   C := alpha*A^T*B + alpha*B^T*A +
                                          beta*C.
                TRANS = 'C' or 'c'   C := alpha*A^T*B + alpha*B^T*A +
                                          beta*C.

n Int32

             On entry,  N specifies the order of the matrix C.  N must be
             at least zero.

k Int32

             On entry with  TRANS = 'N' or 'n',  K  specifies  the number
             of  columns  of the  matrices  A and B,  and on  entry  with
             TRANS = 'T' or 't' or 'C' or 'c',  K  specifies  the  number
             of rows of the matrices  A and B.  K must be at least  zero.

alpha Single

            ALPHA is DOUBLE PRECISION.
             On entry, ALPHA specifies the scalar alpha.

a ReadOnlySpan<Single>

            A is DOUBLE PRECISION array of DIMENSION ( LDA, ka ), where ka is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  A  must contain the matrix  A,  otherwise
             the leading  k by n  part of the array  A  must contain  the
             matrix A.

lda Int32

             On entry, LDA specifies the first dimension of A as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDA must be at least  max( 1, n ), otherwise  LDA must
             be at least  max( 1, k ).

b ReadOnlySpan<Single>

            B is DOUBLE PRECISION array of DIMENSION ( LDB, kb ), where kb is
             k  when  TRANS = 'N' or 'n',  and is  n  otherwise.
             Before entry with  TRANS = 'N' or 'n',  the  leading  n by k
             part of the array  B  must contain the matrix  B,  otherwise
             the leading  k by n  part of the array  B  must contain  the
             matrix B.

ldb Int32

             On entry, LDB specifies the first dimension of B as declared
             in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
             then  LDB must be at least  max( 1, n ), otherwise  LDB must
             be at least  max( 1, k ).

beta Single

            BETA is DOUBLE PRECISION.
             On entry, BETA specifies the scalar beta.

c Span<Single>

            C is DOUBLE PRECISION array of DIMENSION ( LDC, n ).
             Before entry  with  UPLO = 'U' or 'u',  the leading  n by n
             upper triangular part of the array C must contain the upper
             triangular part  of the  symmetric matrix  and the strictly
             lower triangular part of C is not referenced.  On exit, the
             upper triangular part of the array  C is overwritten by the
             upper triangular part of the updated matrix.
             Before entry  with  UPLO = 'L' or 'l',  the leading  n by n
             lower triangular part of the array C must contain the lower
             triangular part  of the  symmetric matrix  and the strictly
             upper triangular part of C is not referenced.  On exit, the
             lower triangular part of the array  C is overwritten by the
             lower triangular part of the updated matrix.

ldc Int32

             On entry, LDC specifies the first dimension of C as declared
             in  the  calling  (sub)  program.   LDC  must  be  at  least
             max( 1, n ).

Implements

ILinearAlgebraOperations<T>.SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, T, ReadOnlySpan<T>, Int32, ReadOnlySpan<T>, Int32, T, Span<T>, Int32)

Remarks

Further Details:

            Level 3 LinearAlgebra routine.
            -- Written on 8-February-1989.
               Jack Dongarra, Argonne National Laboratory.
               Iain Duff, AERE Harwell.
               Jeremy Du Croz, Numerical Algorithms Group Ltd.
               Sven Hammarling, Numerical Algorithms Group Ltd.

Authors: Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver, NAG Ltd.

Date: November 2011

ManagedLinearAlgebraOperationsOfSingle.SymmetricRankUpdate Method

Definition

Overload List

SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)

Parameters

Implements

Remarks

Further Details:

SymmetricRankUpdate(MatrixTriangle, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Span<Single>, Int32)

Parameters

Implements

Remarks

Further Details:

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)

Parameters

Implements

Remarks

Further Details:

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)

Parameters

Implements

Remarks

Further Details:

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Complex<Single>, ReadOnlySpan<Complex<Single>>, Int32, ReadOnlySpan<Complex<Single>>, Int32, Complex<Single>, Span<Complex<Single>>, Int32)

Parameters

Implements

Remarks

Further Details:

SymmetricRankUpdate(MatrixTriangle, TransposeOperation, Int32, Int32, Single, ReadOnlySpan<Single>, Int32, ReadOnlySpan<Single>, Int32, Single, Span<Single>, Int32)

Parameters

Implements

Remarks

Further Details:

See Also

Reference