C++ (Cpp) magma_z_csr_compressor Examples

Example #1

File: magma_zmcsrcompressor.cpp Project: xulunfan/magma

extern "C" magma_int_t
magma_zmcsrcompressor(
    magma_z_matrix *A,
    magma_queue_t queue )
{
    magma_int_t info = 0;

    magma_z_matrix B={Magma_CSR};
    magma_z_matrix hA={Magma_CSR}, CSRA={Magma_CSR};
        
    if ( A->memory_location == Magma_CPU && A->storage_type == Magma_CSR ) {
        CHECK( magma_zmconvert( *A, &B, Magma_CSR, Magma_CSR, queue ));

        magma_free_cpu( A->row );
        magma_free_cpu( A->col );
        magma_free_cpu( A->val );
        CHECK( magma_z_csr_compressor(&B.val, &B.row, &B.col,
                       &A->val, &A->row, &A->col, &A->num_rows, queue ));
        A->nnz = A->row[A->num_rows];
    }
    else {
        magma_storage_t A_storage = A->storage_type;
        magma_location_t A_location = A->memory_location;
        CHECK( magma_zmtransfer( *A, &hA, A->memory_location, Magma_CPU, queue ));
        CHECK( magma_zmconvert( hA, &CSRA, hA.storage_type, Magma_CSR, queue ));

        CHECK( magma_zmcsrcompressor( &CSRA, queue ));

        magma_zmfree( &hA, queue );
        magma_zmfree( A, queue );
        CHECK( magma_zmconvert( CSRA, &hA, Magma_CSR, A_storage, queue ));
        CHECK( magma_zmtransfer( hA, A, Magma_CPU, A_location, queue ));
        magma_zmfree( &hA, queue );
        magma_zmfree( &CSRA, queue );
    }
    
cleanup:
    magma_zmfree( &hA, queue );
    magma_zmfree( &CSRA, queue );
    magma_zmfree( &B, queue );
    return info;
}

Example #2

extern "C" magma_int_t
magma_zjacobisetup(
    magma_z_sparse_matrix A, magma_z_vector b, 
    magma_z_sparse_matrix *M, magma_z_vector *c,
    magma_queue_t queue )
{
    magma_int_t i;

    magma_z_sparse_matrix A_h1, A_h2, B, C;
    magma_z_vector diag, c_t, b_h;
    magma_z_vinit( &c_t, Magma_CPU, A.num_rows, MAGMA_Z_ZERO, queue );
    magma_z_vinit( &diag, Magma_CPU, A.num_rows, MAGMA_Z_ZERO, queue );
    magma_z_vtransfer( b, &b_h, A.memory_location, Magma_CPU, queue );

    if ( A.storage_type != Magma_CSR ) {
        magma_z_mtransfer( A, &A_h1, A.memory_location, Magma_CPU, queue );
        magma_z_mconvert( A_h1, &B, A_h1.storage_type, Magma_CSR, queue );
    }
    else {
        magma_z_mtransfer( A, &B, A.memory_location, Magma_CPU, queue );
    }
    for( magma_int_t rowindex=0; rowindex<B.num_rows; rowindex++ ) {
        magma_int_t start = (B.drow[rowindex]);
        magma_int_t end = (B.drow[rowindex+1]);
        for( i=start; i<end; i++ ) {
            if ( B.dcol[i]==rowindex ) {
                diag.val[rowindex] = B.val[i];
                if ( MAGMA_Z_REAL( diag.val[rowindex]) == 0 )
                    printf(" error: zero diagonal element in row %d!\n", 
                                                               (int) rowindex);
            }
        }
        for( i=start; i<end; i++ ) {
            B.val[i] = B.val[i] / diag.val[rowindex];
            if ( B.dcol[i]==rowindex ) {
                B.val[i] = MAGMA_Z_MAKE( 0., 0. );
            }
        }
        c_t.val[rowindex] = b_h.val[rowindex] / diag.val[rowindex];

    }

    magma_z_csr_compressor(&B.val, &B.drow, &B.dcol, 
                           &C.val, &C.drow, &C.dcol, &B.num_rows, queue );  

    C.num_rows = B.num_rows;
    C.num_cols = B.num_cols;
    C.memory_location = B.memory_location;
    C.nnz = C.drow[B.num_rows];
    C.storage_type = B.storage_type;
    C.memory_location = B.memory_location;
    if ( A.storage_type != Magma_CSR) {
        A_h2.alignment = A.alignment;
        A_h2.blocksize = A.blocksize;
        magma_z_mconvert( C, &A_h2, Magma_CSR, A_h1.storage_type, queue );
        magma_z_mtransfer( A_h2, M, Magma_CPU, A.memory_location, queue );
    }
    else {
        magma_z_mtransfer( C, M, Magma_CPU, A.memory_location, queue );
    }     
    magma_z_vtransfer( c_t, c, Magma_CPU, A.memory_location, queue );

    if ( A.storage_type != Magma_CSR) {
        magma_z_mfree( &A_h1, queue );
        magma_z_mfree( &A_h2, queue );   
    }   
    magma_z_mfree( &B, queue );
    magma_z_mfree( &C, queue );  
    magma_z_vfree( &diag, queue );
    magma_z_vfree( &c_t, queue );
    magma_z_vfree( &b_h, queue );

    return MAGMA_SUCCESS;
}