vsip_cmprodh_p - Complex Matrix Product with Hermitian Transpose

Core

This manual is preliminary and incomplete.
While our Core implementation implements all functions given in the standard we are still working on completing this documentation.

Please refer to the VSIPL standard for a complete function reference of the Core profile until we have completed work on this documentation.

[next] [prev] [prev-tail] [tail] [up]

6.1.12 vsip_cmprodh_p - Complex Matrix Product with Hermitian Transpose

void vsip_cmprodh_f(const vsip_cmview_f *a, const vsip_cmview_f *b, const vsip_cmview_f *r);

Description

This function computes the product of a complex matrix $A$ with the Hermitian transpose of a complex matrix $B$ , storing the result in complex matrix $R$ . The operation performed is:

r = ∑︁n a ·b--- i,j k=1 i,k j,k

for all $i$ and $j$ , where $A$ is an $m × n$ complex matrix, $B$ is a $p ×n$ complex matrix, and $R$ is the resulting $m ×p$ complex matrix. $---- bj,k$ denotes the complex conjugate of $bj,k$ .

Parameters

const vsip_cmview_p* a: First input matrix of size $m × n$ (complex).
const vsip_cmview_p* b: Second input matrix of size $p× n$ (complex), which will be Hermitian transposed in the operation.
const vsip_cmview_p* r: Output matrix of size $m × p$ (complex) that will store the result.

Example

vsip_cmview_f *A, *B, *R; 
vsip_length m = 2, n = 3, p = 2; 
 
// Create complex matrices 
A = vsip_cmcreate_f(m, n, VSIP_ROW, VSIP_MEM_NONE); 
B = vsip_cmcreate_f(p, n, VSIP_ROW, VSIP_MEM_NONE); 
R = vsip_cmcreate_f(m, p, VSIP_ROW, VSIP_MEM_NONE); 
 
// Initialize matrices A and B with complex values 
for (vsip_index i = 0; i < m; i++) { 
    for (vsip_index j = 0; j < n; j++) { 
        vsip_cscalar_f val = VSIP_CMPLX_F(i*n + j + 1, -(i*n + j + 1)); 
        vsip_cmput_f(A, i, j, val); 
    } 
} 
 
for (vsip_index i = 0; i < p; i++) { 
    for (vsip_index j = 0; j < n; j++) { 
        vsip_cscalar_f val = VSIP_CMPLX_F(i*n + j + 1, i*n + j + 2); 
        vsip_cmput_f(B, i, j, val); 
    } 
} 
 
// Compute matrix product with Hermitian transpose: R = A * B^H 
vsip_cmprodh_f(A, B, R); 
 
// Print the result 
printf("Result matrix R = A * B^H (%lux%lu):\n", m, p); 
for (vsip_index i = 0; i < m; i++) { 
    for (vsip_index j = 0; j < p; j++) { 
        vsip_cscalar_f val = vsip_cmget_f(R, i, j); 
        printf("(%.2f%+.2fi) ", val.r, val.i); 
    } 
    printf("\n"); 
} 
 
// Clean up 
vsip_cmalldestroy_f(A); 
vsip_cmalldestroy_f(B); 
vsip_cmalldestroy_f(R);

Notes

The input matrices must have compatible dimensions: Both matrices $A$ and $B$ must have the same number of columns ( $n$ ).
The output matrix $R$ must have dimensions $m ×p$ , where $m$ is the number of rows in $A$ and $p$ is the number of rows in $B$ .
If you need more flexibility in choosing which matrix to transpose, consider using vsip_cgemp_p instead.

[next] [prev] [prev-tail] [front] [up]