GenericLinearAlgebraOperations<T>.PackedSymmetricMultiplyAndAddInPlace Method

public void PackedSymmetricMultiplyAndAddInPlace(
	MatrixTriangle uplo,
	int n,
	T alpha,
	Array1D<T> ap,
	ArraySlice<T> x,
	T beta,
	ArraySlice<T> y
)

Public Sub PackedSymmetricMultiplyAndAddInPlace ( 
	uplo As MatrixTriangle,
	n As Integer,
	alpha As T,
	ap As Array1D(Of T),
	x As ArraySlice(Of T),
	beta As T,
	y As ArraySlice(Of T)
)

public:
void PackedSymmetricMultiplyAndAddInPlace(
	MatrixTriangle uplo, 
	int n, 
	T alpha, 
	Array1D<T> ap, 
	ArraySlice<T> x, 
	T beta, 
	ArraySlice<T> y
)

member PackedSymmetricMultiplyAndAddInPlace : 
        uplo : MatrixTriangle * 
        n : int * 
        alpha : 'T * 
        ap : Array1D<'T> * 
        x : ArraySlice<'T> * 
        beta : 'T * 
        y : ArraySlice<'T> -> unit 

Parameters

uplo  MatrixTriangle

             On entry, UPLO specifies whether the upper or lower
             triangular part of the matrix A is supplied in the packed
             array AP as follows:
                UPLO = 'U' or 'u'   The upper triangular part of A is
                                    supplied in AP.
                UPLO = 'L' or 'l'   The lower triangular part of A is
                                    supplied in AP.
            

n  Int32

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

alpha  T

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

ap  Array1D<T>

            AP is DOUBLE PRECISION array of DIMENSION at least
             ( ( n*( n + 1 ) )/2 ).
             Before entry with UPLO = 'U' or 'u', the array AP must
             contain the upper triangular part of the symmetric matrix
             packed sequentially, column by column, so that AP( 1 )
             contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )
             and a( 2, 2 ) respectively, and so on.
             Before entry with UPLO = 'L' or 'l', the array AP must
             contain the lower triangular part of the symmetric matrix
             packed sequentially, column by column, so that AP( 1 )
             contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )
             and a( 3, 1 ) respectively, and so on.
            

x  ArraySlice<T>

            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.
            

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

beta  T

            BETA is DOUBLE PRECISION.
             On entry, BETA specifies the scalar beta. When BETA is
             supplied as zero then Y need not be set on input.
            

y  ArraySlice<T>

            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. On exit, Y is overwritten by the updated
             vector y.
            

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

 Further Details:
            Level 2 LinearAlgebra routine.
            The vector and matrix arguments are not referenced when N = 0, or M = 0
            -- 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

Reference