int test_pluq_structured(rci_t m, rci_t n) {
printf("pluq: testing structured m: %5d, n: %5d", m, n);
mzd_t* A = mzd_init(m, n);
mzd_t* L = mzd_init(m, m);
mzd_t* U = mzd_init(m, n);
for(rci_t i = 0; i < m; i += 2)
for (rci_t j = i; j < n; ++j)
mzd_write_bit(A, i, j, 1);
mzd_t* Acopy = mzd_copy (NULL,A);
mzp_t* P = mzp_init(m);
mzp_t* Q = mzp_init(n);
rci_t r = mzd_pluq(A, P, Q, 0);
printf(", rank: %5d ",r);
for (rci_t i = 0; i < r; ++i){
for (rci_t j = 0; j < i; ++j)
mzd_write_bit(L, i, j, mzd_read_bit(A,i,j));
for (rci_t j = i + 1; j < n; ++j)
mzd_write_bit(U, i, j, mzd_read_bit(A,i,j));
}
for (rci_t i = r; i < m; ++i)
for (rci_t j = 0; j < r; ++j)
mzd_write_bit(L, i, j, mzd_read_bit(A,i,j));
for (rci_t i = 0; i < r; ++i){
mzd_write_bit(L,i,i, 1);
mzd_write_bit(U,i,i, 1);
}
mzd_apply_p_left(Acopy, P);
mzd_apply_p_right_trans(Acopy, Q);
mzd_addmul(Acopy, L, U, 0);
int status = 0;
for (rci_t i = 0; i < m; ++i)
for (rci_t j = 0; j < n; ++j){
if (mzd_read_bit (Acopy,i,j)){
status = 1;
break;
}
}
if (status) {
printf("\n");
printf(" ... FAILED\n");
} else
printf (" ... passed\n");
mzd_free(U);
mzd_free(L);
mzd_free(A);
mzd_free(Acopy);
mzp_free(P);
mzp_free(Q);
return status;
}
int _mzd_pluq_solve_left(mzd_t const *A, rci_t rank,
mzp_t const *P, mzp_t const *Q,
mzd_t *B, int const cutoff, int const inconsistency_check) {
/** A is supposed to store L lower triangular and U upper triangular
* B is modified in place
* (Bi's in the comments are just modified versions of B)
* PLUQ = A
* 1) P B2 = B1
* 2) L B3 = B2
* 3) U B4 = B3
* 4) Q B5 = B4
*/
int retval = 0;
/* P B2 = B1 or B2 = P^T B1 */
mzd_apply_p_left(B, P);
/* L B3 = B2 */
/* view on the upper part of L */
mzd_t const *LU = mzd_init_window_const(A, 0, 0, rank, rank);
mzd_t *Y1 = mzd_init_window(B, 0, 0, rank, B->ncols);
mzd_trsm_lower_left(LU, Y1, cutoff);
if (inconsistency_check) { /* Check for inconsistency */
/** FASTER without this check; update with the lower part of L
*/
mzd_t const *H = mzd_init_window_const(A, rank, 0, A->nrows, rank);
mzd_t *Y2 = mzd_init_window(B, rank, 0, A->nrows, B->ncols);
if(A->nrows < B->nrows) {
mzd_t *Y3 = mzd_init_window(B, A->nrows, 0, B->nrows, B->ncols);
mzd_set_ui(Y3, 0);
mzd_free_window(Y3);
}
mzd_addmul(Y2, H, Y1, cutoff);
/*
* test whether Y2 is the zero matrix
*/
if(!mzd_is_zero(Y2)) {
retval = -1;
}
mzd_free_window((mzd_t*)H);
mzd_free_window(Y2);
}
/* U B4 = B3 */
mzd_trsm_upper_left(LU, Y1, cutoff);
mzd_free_window((mzd_t*)LU);
mzd_free_window(Y1);
if (!inconsistency_check) {
/** Default is to set the undefined bits to zero if inconsistency
* has been checked then Y2 bits are already all zeroes thus this
* clearing is not needed
*/
for(rci_t i = rank; i < B->nrows; ++i) {
for(rci_t j = 0; j < B->ncols; j += m4ri_radix) {
mzd_clear_bits(B, i, j, MIN(m4ri_radix, B->ncols - j));
}
}
}
/* Q B5 = B4 or B5 = Q^T B4 */
mzd_apply_p_left_trans(B, Q);
/* P L U Q B5 = B1 */
__M4RI_DD_MZD(B);
__M4RI_DD_INT(retval);
return retval;
}
int test_lqup_half_rank(size_t m, size_t n) {
printf("pluq: testing half rank m: %5zd, n: %5zd",m,n);
mzd_t* U = mzd_init(m, n);
mzd_t* L = mzd_init(m, m);
mzd_t* U2 = mzd_init(m, n);
mzd_t* L2 = mzd_init(m, m);
mzd_t* A = mzd_init(m, n);
mzd_randomize (U);
mzd_randomize (L);
size_t i,j;
for (i=0; i<m && i<n; ++i){
mzd_write_bit(U,i,i, 1);
for (j=0; j<i;++j)
mzd_write_bit(U,i,j, 0);
if (i%2)
for (j=i; j<n;++j)
mzd_write_bit(U,i,j, 0);
for (j=i+1; j<m;++j)
mzd_write_bit(L,i,j, 0);
mzd_write_bit(L,i,i, 1);
}
mzd_mul(A, L, U, 0);
mzd_t* Acopy = mzd_copy (NULL,A);
mzp_t* Pt = mzp_init(m);
mzp_t* Q = mzp_init(n);
int r = mzd_pluq(A, Pt, Q, 0);
for (i=0; i<r; ++i){
for (j=0; j<i;++j)
mzd_write_bit (L2, i, j, mzd_read_bit(A,i,j));
for (j=i+1; j<n;++j)
mzd_write_bit (U2, i, j, mzd_read_bit(A,i,j));
}
for (i=r; i<m; i++)
for (j=0; j<r;++j)
mzd_write_bit (L2, i, j, mzd_read_bit(A,i,j));
for (i=0; i<r; ++i){
mzd_write_bit(L2,i,i, 1);
mzd_write_bit(U2,i,i, 1);
}
mzd_apply_p_left(Acopy, Pt);
mzd_apply_p_right_trans(Acopy, Q);
mzd_addmul(Acopy,L2,U2,0);
int status = 0;
for ( i=0; i<m; ++i) {
for ( j=0; j<n; ++j){
if (mzd_read_bit(Acopy,i,j)){
status = 1;
}
}
if(status)
break;
}
if (status)
printf(" ... FAILED\n");
else
printf (" ... passed\n");
mzd_free(U);
mzd_free(L);
mzd_free(U2);
mzd_free(L2);
mzd_free(A);
mzd_free(Acopy);
mzp_free(Pt);
mzp_free(Q);
return status;
}
