Function

cblas_zhemm(_:_:_:_:_:_:_:_:_:_:_:_:_:)

Multiplies two Hermitian matrices (double-precision complex).

Declaration

func cblas_zhemm(_ __Order: CBLAS_ORDER, _ __Side: CBLAS_SIDE, _ __Uplo: CBLAS_UPLO, _ __M: Int32, _ __N: Int32, _ __alpha: UnsafeRawPointer!, _ __A: UnsafeRawPointer!, _ __lda: Int32, _ __B: UnsafeRawPointer!, _ __ldb: Int32, _ __beta: UnsafeRawPointer!, _ __C: UnsafeMutableRawPointer!, _ __ldc: Int32)

Parameters

Order

Specifies row-major (C) or column-major (Fortran) data ordering.

Side

Determines the order in which the matrices should be multiplied.

Uplo

Specifies whether to use the upper or lower triangle from the matrix. Valid values are 'U' or 'L'.

M

The number of rows in matrices A and C.

N

The number of columns in matrices B and C.

alpha

Scaling factor for the product of matrices A and B.

A

Matrix A.

lda

The size of the first dimention of matrix A; if you are passing a matrix A[m][n], the value should be m.

B

Matrix B.

ldb

The size of the first dimention of matrix B; if you are passing a matrix B[m][n], the value should be m.

beta

Scaling factor for matrix C.

C

Matrix C.

ldc

The size of the first dimention of matrix C; if you are passing a matrix C[m][n], the value should be m.

Discussion

This function multiplies A * B or B * A (depending on the value of Side) and multiplies the resulting matrix by alpha. It then multiplies matrix C by beta. It stores the sum of these two products in matrix C.

Thus, it calculates either

C←αAB + βC

or

C←αBA + βC

where

A = AH

See Also

Double-Precision Complex Matrix Functions

func cblas_dzasum(Int32, UnsafeRawPointer!, Int32) -> Double

Computes the sum of the absolute values of real and imaginary parts of elements in a vector (single-precision complex).

func cblas_dznrm2(Int32, UnsafeRawPointer!, Int32) -> Double

Computes the unitary norm of a vector (double-precision complex).

func cblas_zaxpy(Int32, UnsafeRawPointer!, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Computes a constant times a vector plus a vector (double-precision complex).

func cblas_zcopy(Int32, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Copies a vector to another vector (double-precision complex).

func cblas_zdscal(Int32, Double, UnsafeMutableRawPointer!, Int32)

Multiplies each element of a vector by a constant (double-precision complex).

func cblas_zgerc(CBLAS_ORDER, Int32, Int32, UnsafeRawPointer!, UnsafeRawPointer!, Int32, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Multiplies vector X by the conjugate transpose of vector Y, then adds matrix A (double-precision complex).

func cblas_zher(CBLAS_ORDER, CBLAS_UPLO, Int32, Double, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Adds the product of a scaling factor, vector X, and the conjugate transpose of X to matrix A.

func cblas_zher2(CBLAS_ORDER, CBLAS_UPLO, Int32, UnsafeRawPointer!, UnsafeRawPointer!, Int32, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Hermitian rank 2 update: adds the product of a scaling factor, vector X, and the conjugate transpose of vector Y to the product of the conjugate of the scaling factor, vector Y, and the conjugate transpose of vector X, and adds the result to matrix A.

func cblas_zherk(CBLAS_ORDER, CBLAS_UPLO, CBLAS_TRANSPOSE, Int32, Int32, Double, UnsafeRawPointer!, Int32, Double, UnsafeMutableRawPointer!, Int32)

Rank-k update—multiplies a Hermitian matrix by its transpose and adds a second matrix (single precision).

func cblas_zhpr(CBLAS_ORDER, CBLAS_UPLO, Int32, Double, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!)

Scales and multiplies a vector times its conjugate transpose, then adds a matrix.

func cblas_zhpr2(CBLAS_ORDER, CBLAS_UPLO, Int32, UnsafeRawPointer!, UnsafeRawPointer!, Int32, UnsafeRawPointer!, Int32, UnsafeMutableRawPointer!)

Multiplies a vector times the conjugate transpose of a second vector and vice-versa, sums the results, and adds a matrix.

func cblas_zscal(Int32, UnsafeRawPointer!, UnsafeMutableRawPointer!, Int32)

Multiplies each element of a vector by a constant (double-precision complex).

func cblas_zswap(Int32, UnsafeMutableRawPointer!, Int32, UnsafeMutableRawPointer!, Int32)

Exchanges the elements of two vectors (double-precision complex).

func cblas_zsyrk(CBLAS_ORDER, CBLAS_UPLO, CBLAS_TRANSPOSE, Int32, Int32, UnsafeRawPointer!, UnsafeRawPointer!, Int32, UnsafeRawPointer!, UnsafeMutableRawPointer!, Int32)

Rank-k update—multiplies a symmetric matrix by its transpose and adds a second matrix (double-precision complex).

func cblas_ztpmv(CBLAS_ORDER, CBLAS_UPLO, CBLAS_TRANSPOSE, CBLAS_DIAG, Int32, UnsafeRawPointer!, UnsafeMutableRawPointer!, Int32)

Multiplies a triangular matrix by a vector, then adds a vector (double-precision compex).