void basisproduct_clusteroperator(pcclusterbasis cb1, pcclusterbasis cb2, pclusteroperator pr) { pamatrix X, Xt; amatrix tmp1, tmp2; uint i; assert(cb1->t == pr->t); assert(cb2->t == pr->t); resize_clusteroperator(pr, cb1->k, cb2->k); if (pr->sons > 0) { assert(cb1->sons == pr->sons); assert(cb2->sons == pr->sons); for (i = 0; i < pr->sons; i++) basisproduct_clusteroperator(cb1->son[i], cb2->son[i], pr->son[i]); clear_amatrix(&pr->C); for (i = 0; i < pr->sons; i++) { X = init_amatrix(&tmp1, cb1->son[i]->k, cb2->k); clear_amatrix(X); addmul_amatrix(1.0, false, &pr->son[i]->C, false, &cb2->son[i]->E, X); addmul_amatrix(1.0, true, &cb1->son[i]->E, false, X, &pr->C); uninit_amatrix(X); } } else { if (cb1->sons == 0) { if (cb2->sons == 0) { clear_amatrix(&pr->C); addmul_amatrix(1.0, true, &cb1->V, false, &cb2->V, &pr->C); } else { Xt = init_amatrix(&tmp1, cb2->kbranch, cb1->k); compress_clusterbasis_amatrix(cb2, &cb1->V, Xt); X = init_sub_amatrix(&tmp2, Xt, cb2->k, 0, cb1->k, 0); copy_amatrix(true, X, &pr->C); uninit_amatrix(X); uninit_amatrix(Xt); } } else { assert(cb2->sons == 0); /* Could be generalized */ Xt = init_amatrix(&tmp1, cb1->kbranch, cb2->k); compress_clusterbasis_amatrix(cb1, &cb2->V, Xt); X = init_sub_amatrix(&tmp2, Xt, cb1->k, 0, cb2->k, 0); copy_amatrix(false, X, &pr->C); uninit_amatrix(X); uninit_amatrix(Xt); } } }
void clear_hmatrix(phmatrix hm) { if (hm->son) { int rsons = hm->rsons; int csons = hm->csons; for (int j=0;j<csons;j++) { for (int i=0;i<rsons;i++) { clear_hmatrix(hm->son[i+j*rsons]); } } } else if(hm->r) { setrank_rkmatrix(hm->r, 0); } else { assert(hm->f); clear_amatrix(hm->f); } }
void add_projected_uniform(pcuniform u, pcclusteroperator ro, pcclusteroperator co, puniform unew) { amatrix tmp; pamatrix XS; if (u->rb == unew->rb) { if (u->cb == unew->cb) add_amatrix(1.0, false, &u->S, &unew->S); else { assert(co->krow == unew->cb->k); assert(co->kcol == u->cb->k); addmul_amatrix(1.0, false, &u->S, true, &co->C, &unew->S); } } else { if (u->cb == unew->cb) { assert(ro->krow == unew->rb->k); assert(ro->kcol == u->rb->k); addmul_amatrix(1.0, false, &ro->C, false, &u->S, &unew->S); } else { assert(ro->krow == unew->rb->k); assert(ro->kcol == u->rb->k); assert(co->krow == unew->cb->k); assert(co->kcol == u->cb->k); XS = init_amatrix(&tmp, unew->rb->k, u->cb->k); clear_amatrix(XS); addmul_amatrix(1.0, false, &ro->C, false, &u->S, XS); addmul_amatrix(1.0, false, XS, true, &co->C, &unew->S); uninit_amatrix(XS); } } }
static real compareweights(pcclusteroperator co1, pcclusteroperator co2, uint level) { amatrix tmp; pamatrix D; real norm, error, error1; uint k; uint i; k = co1->kcol; assert(k == co2->kcol); D = init_amatrix(&tmp, k, k); clear_amatrix(D); addmul_amatrix(1.0, true, &co1->C, false, &co1->C, D); norm = norm2_amatrix(D); addmul_amatrix(-1.0, true, &co2->C, false, &co2->C, D); error = norm2_amatrix(D); uninit_amatrix(D); if (norm > 0.0) error /= norm; if (co1->sons != co2->sons) printf("Tree mismatch"); else for (i = 0; i < co1->sons; i++) { error1 = compareweights(co1->son[i], co2->son[i], level + 1); if (error1 > error) error = error1; } return error; }
static void check_triangularaddmul(bool alower, bool atrans, bool blower, bool btrans) { pamatrix a, b, at, bt, x; amatrix atmp, btmp, attmp, bttmp, xtmp; real error; uint dim1, dim2, dim3; dim1 = 100; dim2 = 80; dim3 = 90; a = (atrans ? init_amatrix(&atmp, dim2, dim1) : init_amatrix(&atmp, dim1, dim2)); random_amatrix(a); b = (btrans ? init_amatrix(&btmp, dim3, dim2) : init_amatrix(&btmp, dim2, dim3)); random_amatrix(b); at = init_amatrix(&attmp, a->rows, a->cols); if (alower) copy_lower_amatrix(a, false, at); else copy_upper_amatrix(a, false, at); bt = init_amatrix(&bttmp, b->rows, b->cols); if (blower) copy_lower_amatrix(b, false, bt); else copy_upper_amatrix(b, false, bt); x = init_amatrix(&xtmp, dim1, dim3); clear_amatrix(x); triangularaddmul_amatrix(1.0, alower, atrans, a, blower, btrans, b, x); addmul_amatrix(-1.0, atrans, at, btrans, bt, x); error = norm2_amatrix(x); (void) printf ("Checking triangularaddmul(alower=%s, atrans=%s, blower=%s, btrans=%s)\n" " Accuracy %g, %sokay\n", (alower ? "tr" : "fl"), (atrans ? "tr" : "fl"), (blower ? "tr" : "fl"), (btrans ? "tr" : "fl"), error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; uninit_amatrix(x); uninit_amatrix(bt); uninit_amatrix(at); uninit_amatrix(b); uninit_amatrix(a); dim1 = 70; dim2 = 80; dim3 = 90; a = (atrans ? init_amatrix(&atmp, dim2, dim1) : init_amatrix(&atmp, dim1, dim2)); random_amatrix(a); b = (btrans ? init_amatrix(&btmp, dim3, dim2) : init_amatrix(&btmp, dim2, dim3)); random_amatrix(b); at = init_amatrix(&attmp, a->rows, a->cols); if (alower) copy_lower_amatrix(a, false, at); else copy_upper_amatrix(a, false, at); bt = init_amatrix(&bttmp, b->rows, b->cols); if (blower) copy_lower_amatrix(b, false, bt); else copy_upper_amatrix(b, false, bt); x = init_amatrix(&xtmp, dim1, dim3); clear_amatrix(x); triangularaddmul_amatrix(1.0, alower, atrans, a, blower, btrans, b, x); addmul_amatrix(-1.0, atrans, at, btrans, bt, x); error = norm2_amatrix(x); (void) printf ("Checking triangularaddmul(alower=%s, atrans=%s, blower=%s, btrans=%s)\n" " Accuracy %g, %sokay\n", (alower ? "tr" : "fl"), (atrans ? "tr" : "fl"), (blower ? "tr" : "fl"), (btrans ? "tr" : "fl"), error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; uninit_amatrix(x); uninit_amatrix(bt); uninit_amatrix(at); uninit_amatrix(b); uninit_amatrix(a); }
void project_inplace_uniform(puniform u, pclusterbasis rb, pcclusteroperator ro, pclusterbasis cb, pcclusteroperator co) { amatrix tmp; pamatrix X; if (u->rb == rb) { if (u->cb == cb) { /* Nothing to do */ } else { assert(co); assert(co->krow == cb->k); assert(co->kcol == u->cb->k); /* Transform coupling matrix */ X = init_amatrix(&tmp, u->rb->k, cb->k); clear_amatrix(X); addmul_amatrix(1.0, false, &u->S, true, &co->C, X); resize_amatrix(&u->S, X->rows, X->cols); copy_amatrix(false, X, &u->S); uninit_amatrix(X); /* Update pointer */ ref_col_uniform(u, cb); } } else { assert(ro); assert(ro->krow == rb->k); assert(ro->kcol == u->rb->k); if (u->cb == cb) { /* Transform coupling matrix */ X = init_amatrix(&tmp, rb->k, u->cb->k); clear_amatrix(X); addmul_amatrix(1.0, false, &ro->C, false, &u->S, X); resize_amatrix(&u->S, X->rows, X->cols); copy_amatrix(false, X, &u->S); uninit_amatrix(X); /* Update pointer */ ref_row_uniform(u, rb); } else { assert(co); assert(co->krow == cb->k); assert(co->kcol == u->cb->k); /* Transform coupling matrix for row... */ X = init_amatrix(&tmp, rb->k, u->cb->k); clear_amatrix(X); addmul_amatrix(1.0, false, &ro->C, false, &u->S, X); /* ... and column basis */ resize_amatrix(&u->S, rb->k, cb->k); clear_amatrix(&u->S); addmul_amatrix(1.0, false, X, true, &co->C, &u->S); uninit_amatrix(X); /* Update pointers */ ref_row_uniform(u, rb); ref_col_uniform(u, cb); } } }
void clear_uniform(puniform u) { clear_amatrix(&u->S); }
int main() { ptridiag T, Tcopy; pamatrix A, Acopy, Q, U, Vt; pavector work; prealavector sigma, lambda; real error; uint rows, cols, mid; uint i, n, iter; int info; /* ------------------------------------------------------------ * Testing symmetric tridiagonal eigenvalue solver * ------------------------------------------------------------ */ n = 6; /* Testing symmetric tridiagonal eigenvalue solver */ (void) printf("==================================================\n" "Testing symmetric tridiagonal eigenvalue solver\n" "==================================================\n" "Setting up %u x %u tridiagonal matrix\n", n, n); T = new_tridiag(n); for (i = 0; i < n; i++) T->d[i] = 2.0; for (i = 0; i < n - 1; i++) T->l[i] = T->u[i] = -1.0; Tcopy = new_tridiag(n); copy_tridiag(T, Tcopy); A = new_amatrix(n, n); clear_amatrix(A); for (i = 0; i < n; i++) A->a[i + i * A->ld] = T->d[i]; for (i = 0; i < n - 1; i++) { A->a[(i + 1) + i * A->ld] = T->l[i]; A->a[i + (i + 1) * A->ld] = T->u[i]; } Acopy = clone_amatrix(A); Q = new_identity_amatrix(n, n); U = new_amatrix(n, n); (void) printf("Performing self-made implicit QR iteration\n"); iter = sb_muleig_tridiag(T, Q, 8 * n); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Q, U); diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, true, Q, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g. %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; (void) printf("Performing default implicit QR iteration\n"); identity_amatrix(Q); i = muleig_tridiag(Tcopy, Q); if (i == 0) (void) printf(" Success\n"); else { (void) printf(" Failure\n"); problems++; } (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Q, U); diageval_tridiag_amatrix(1.0, true, Tcopy, true, U); addmul_amatrix(-1.0, false, U, true, Q, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g. %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; del_amatrix(U); del_amatrix(Q); del_amatrix(Acopy); del_amatrix(A); del_tridiag(Tcopy); del_tridiag(T); (void) printf("--------------------------------------------------\n" "Setting up random %u x %u tridiagonal matrix\n", n, n); T = new_tridiag(n); for (i = 0; i < n; i++) T->d[i] = 2.0 * rand() / RAND_MAX - 1.0; for (i = 0; i < n - 1; i++) { T->l[i] = 2.0 * rand() / RAND_MAX - 1.0; T->u[i] = CONJ(T->l[i]); } A = new_amatrix(n, n); clear_amatrix(A); for (i = 0; i < n; i++) A->a[i + i * A->ld] = T->d[i]; for (i = 0; i < n - 1; i++) { A->a[(i + 1) + i * A->ld] = T->l[i]; A->a[i + (i + 1) * A->ld] = T->u[i]; } Tcopy = new_tridiag(n); copy_tridiag(T, Tcopy); Acopy = clone_amatrix(A); Q = new_identity_amatrix(n, n); U = new_amatrix(n, n); (void) printf("Performing implicit QR iteration\n"); iter = sb_muleig_tridiag(T, Q, 8 * n); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Q, U); diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, true, Q, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; (void) printf("Using default eigenvalue solver\n"); identity_amatrix(Q); muleig_tridiag(Tcopy, Q); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Q, U); diageval_tridiag_amatrix(1.0, true, Tcopy, true, U); addmul_amatrix(-1.0, false, U, true, Q, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : " NOT ")); if (error >= tolerance) problems++; del_amatrix(U); del_amatrix(Q); del_amatrix(Acopy); del_amatrix(A); del_tridiag(Tcopy); del_tridiag(T); /* ------------------------------------------------------------ * Testing self-adjoint matrix eigenvalue solver * ------------------------------------------------------------ */ (void) printf("==================================================\n" "Testing self-adjoint matrix eigenvalue solver\n" "==================================================\n" "Setting up random %u x %u self-adjoint matrix\n", n, n); A = new_amatrix(n, n); random_selfadjoint_amatrix(A); Acopy = new_amatrix(n, n); copy_amatrix(false, A, Acopy); lambda = new_realavector(n); Q = new_identity_amatrix(n, n); (void) printf("Performing implicit QR iteration\n"); iter = sb_eig_amatrix(A, lambda, Q, 8 * n); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; U = new_amatrix(n, n); copy_amatrix(false, Q, U); copy_amatrix(false, Acopy, A); diageval_realavector_amatrix(1.0, true, lambda, true, U); addmul_amatrix(-1.0, false, U, true, Q, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; (void) printf("Using default eigenvalue solver\n"); copy_amatrix(false, Acopy, A); info = eig_amatrix(A, lambda, Q); assert(info == 0); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, Q); (void) printf(" Orthogonality Q %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Q, U); diageval_realavector_amatrix(1.0, true, lambda, true, U); addmul_amatrix(-1.0, false, U, true, Q, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_amatrix(U); del_amatrix(Q); del_realavector(lambda); del_amatrix(Acopy); del_amatrix(A); /* ------------------------------------------------------------ * Testing bidiagonal SVD solver * ------------------------------------------------------------ */ (void) printf("==================================================\n" "Testing bidiagonal SVD solver\n" "==================================================\n" "Setting up bidiagonal %u x %u matrix\n", n, n); T = new_tridiag(n); for (i = 0; i < n; i++) T->d[i] = i + 1.0; for (i = 0; i < n - 1; i++) { T->l[i] = 1.0; T->u[i] = 0.0; } A = new_amatrix(n, n); clear_amatrix(A); for (i = 0; i < n; i++) A->a[i + i * A->ld] = T->d[i]; for (i = 0; i < n - 1; i++) A->a[(i + 1) + i * A->ld] = T->l[i]; Tcopy = new_tridiag(n); copy_tridiag(T, Tcopy); Acopy = new_amatrix(n, n); copy_amatrix(false, A, Acopy); U = new_identity_amatrix(n, n); Vt = new_identity_amatrix(n, n); (void) printf("Performing self-made implicit SVD iteration\n"); iter = sb_mulsvd_tridiag(T, U, Vt, 8 * n); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; (void) printf("Using default SVD solver\n"); copy_tridiag(Tcopy, T); identity_amatrix(U); identity_amatrix(Vt); mulsvd_tridiag(T, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Acopy, A); diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_tridiag(Tcopy); del_amatrix(A); del_tridiag(T); (void) printf("--------------------------------------------------\n" "Setting up random bidiagonal %u x %u matrix\n", n, n); T = new_tridiag(n); for (i = 0; i < n; i++) { T->d[i] = 2.0 * rand() / RAND_MAX - 1.0; } for (i = 0; i < n - 1; i++) { T->l[i] = 2.0 * rand() / RAND_MAX - 1.0; T->u[i] = 0.0; } A = new_amatrix(n, n); clear_amatrix(A); for (i = 0; i < n; i++) A->a[i + i * A->ld] = T->d[i]; for (i = 0; i < n - 1; i++) A->a[(i + 1) + i * A->ld] = T->l[i]; Tcopy = new_tridiag(n); copy_tridiag(T, Tcopy); Acopy = clone_amatrix(A); U = new_identity_amatrix(n, n); Vt = new_identity_amatrix(n, n); (void) printf("Performing implicit SVD iteration\n"); iter = sb_mulsvd_tridiag(T, U, Vt, 8 * n); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; (void) printf("Using default SVD solver\n"); copy_tridiag(Tcopy, T); copy_amatrix(false, Acopy, A); identity_amatrix(U); identity_amatrix(Vt); mulsvd_tridiag(T, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_tridiag(Tcopy); del_amatrix(A); del_tridiag(T); /* ------------------------------------------------------------ * Testing Golub-Kahan bidiagonalization * ------------------------------------------------------------ */ rows = 10; cols = 7; mid = UINT_MIN(rows, cols); (void) printf("==================================================\n" "Testing Golub-Kahan bidiagonalization\n" "==================================================\n" "Setting up random %u x %u matrix\n", rows, cols); A = new_amatrix(rows, cols); random_amatrix(A); Acopy = new_amatrix(rows, cols); copy_amatrix(false, A, Acopy); U = new_amatrix(rows, mid); Vt = new_amatrix(mid, cols); T = new_tridiag(mid); (void) printf("Bidiagonalizing\n"); bidiagonalize_amatrix(A, T, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; lowereval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_tridiag(T); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); rows = 8; cols = 15; mid = UINT_MIN(rows, cols); (void) printf("--------------------------------------------------\n" "Setting up %u x %u matrix\n", rows, cols); A = new_amatrix(rows, cols); random_amatrix(A); Acopy = new_amatrix(rows, cols); copy_amatrix(false, A, Acopy); U = new_amatrix(rows, mid); Vt = new_amatrix(mid, cols); T = new_tridiag(mid); (void) printf("Bidiagonalizing\n"); bidiagonalize_amatrix(A, T, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; lowereval_tridiag_amatrix(1.0, true, T, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_tridiag(T); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); /* ------------------------------------------------------------ * Testing general SVD solver * ------------------------------------------------------------ */ (void) printf("==================================================\n" "Testing general SVD solver\n" "==================================================\n" "Setting up 3 x 4 matrix\n"); A = new_amatrix(3, 4); setentry_amatrix(A, 0, 0, 1.0); setentry_amatrix(A, 1, 0, 2.0); setentry_amatrix(A, 2, 0, 3.0); setentry_amatrix(A, 0, 1, 2.0); setentry_amatrix(A, 1, 1, 4.0); setentry_amatrix(A, 2, 1, 6.0); setentry_amatrix(A, 0, 2, 2.0); setentry_amatrix(A, 1, 2, 5.0); setentry_amatrix(A, 2, 2, 8.0); setentry_amatrix(A, 0, 3, 1.0); setentry_amatrix(A, 1, 3, 4.0); setentry_amatrix(A, 2, 3, 7.0); Acopy = new_amatrix(A->rows, A->cols); copy_amatrix(false, A, Acopy); U = new_identity_amatrix(3, 3); Vt = new_identity_amatrix(3, 4); sigma = new_realavector(3); work = new_avector(3 * 3); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 24); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); (void) printf("--------------------------------------------------\n" "Setting up 4 x 3 matrix\n"); A = new_amatrix(4, 3); setentry_amatrix(A, 0, 0, 1.0); setentry_amatrix(A, 0, 1, 2.0); setentry_amatrix(A, 0, 2, 3.0); setentry_amatrix(A, 1, 0, 2.0); setentry_amatrix(A, 1, 1, 4.0); setentry_amatrix(A, 1, 2, 6.0); setentry_amatrix(A, 2, 0, 2.0); setentry_amatrix(A, 2, 1, 5.0); setentry_amatrix(A, 2, 2, 8.0); setentry_amatrix(A, 3, 0, 1.0); setentry_amatrix(A, 3, 1, 4.0); setentry_amatrix(A, 3, 2, 7.0); Acopy = new_amatrix(A->rows, A->cols); copy_amatrix(false, A, Acopy); U = new_amatrix(4, 3); Vt = new_amatrix(3, 3); sigma = new_realavector(3); work = new_avector(3 * 3); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 24); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality V %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); (void) printf("--------------------------------------------------\n" "Setting up 4 x 3 matrix\n"); A = new_amatrix(4, 3); setentry_amatrix(A, 0, 0, 1.0); setentry_amatrix(A, 0, 1, 2.0); setentry_amatrix(A, 0, 2, 3.0); setentry_amatrix(A, 1, 0, 2.0); setentry_amatrix(A, 1, 1, 4.0); setentry_amatrix(A, 1, 2, 6.0); setentry_amatrix(A, 2, 0, 2.0); setentry_amatrix(A, 2, 1, 5.0); setentry_amatrix(A, 2, 2, 8.0); setentry_amatrix(A, 3, 0, 1.0); setentry_amatrix(A, 3, 1, 4.0); setentry_amatrix(A, 3, 2, 7.0); Acopy = clone_amatrix(A); U = new_amatrix(4, 3); Vt = new_amatrix(3, 3); sigma = new_realavector(3); work = new_avector(3 * 3); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 24); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); rows = 9; cols = 7; mid = UINT_MIN(rows, cols); (void) printf("--------------------------------------------------\n" "Setting up random %u x %u matrix\n", rows, cols); A = new_amatrix(rows, cols); random_amatrix(A); Acopy = new_amatrix(A->rows, A->cols); copy_amatrix(false, A, Acopy); U = new_amatrix(rows, mid); Vt = new_amatrix(mid, cols); sigma = new_realavector(mid); work = new_avector(3 * mid); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 10 * mid); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, Acopy); error = normfrob_amatrix(Acopy); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); rows = 10; cols = 6; mid = UINT_MIN(rows, cols); (void) printf("--------------------------------------------------\n" "Setting up random %u x %u matrix\n", rows, cols); A = new_amatrix(rows, cols); random_amatrix(A); Acopy = new_amatrix(A->rows, A->cols); copy_amatrix(false, A, Acopy); U = new_amatrix(rows, mid); Vt = new_amatrix(mid, cols); sigma = new_realavector(mid); work = new_avector(3 * mid); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 10 * mid); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Acopy, A); diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; (void) printf("Running default SVD solver\n"); copy_amatrix(false, Acopy, A); svd_amatrix(A, sigma, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Acopy, A); diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); rows = 7; cols = 13; mid = UINT_MIN(rows, cols); (void) printf("--------------------------------------------------\n" "Setting up random %u x %u matrix\n", rows, cols); A = new_amatrix(rows, cols); random_amatrix(A); Acopy = new_amatrix(A->rows, A->cols); copy_amatrix(false, A, Acopy); U = new_amatrix(rows, mid); Vt = new_amatrix(mid, cols); sigma = new_realavector(mid); work = new_avector(3 * mid); (void) printf("Running self-made SVD solver\n"); iter = sb_svd_amatrix(A, sigma, U, Vt, 10 * mid); (void) printf(" %u iterations\n", iter); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Acopy, A); diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; (void) printf("Running default SVD solver\n"); copy_amatrix(false, Acopy, A); svd_amatrix(A, sigma, U, Vt); (void) printf("Checking accuracy\n"); error = check_ortho_amatrix(false, U); (void) printf(" Orthogonality U %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; error = check_ortho_amatrix(true, Vt); (void) printf(" Orthogonality Vt %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; copy_amatrix(false, Acopy, A); diageval_realavector_amatrix(1.0, true, sigma, true, U); addmul_amatrix(-1.0, false, U, false, Vt, A); error = normfrob_amatrix(A); (void) printf(" Accuracy %g, %sokay\n", error, (error < tolerance ? "" : "NOT ")); if (error >= tolerance) problems++; del_avector(work); del_realavector(sigma); del_amatrix(Vt); del_amatrix(U); del_amatrix(Acopy); del_amatrix(A); printf("----------------------------------------\n" " %u matrices and\n" " %u vectors still active\n" " %u errors found\n", getactives_amatrix(), getactives_avector(), problems); return problems; }
void coarsen_hmatrix(phmatrix G, ptruncmode tm, real eps, bool recursive) { uint rsons = G->rsons; uint csons = G->csons; phmatrix son; prkmatrix R; pamatrix A, B; amatrix T, S; uint i, j, leafs, ranksum, rankoffset, rowoffset, coloffset, rank; size_t sizeold, sizenew; leafs = 0; /* recursion */ if (rsons * csons > 0) { for (j = 0; j < csons; ++j) { for (i = 0; i < rsons; ++i) { son = G->son[i + j * rsons]; if (recursive == true) { coarsen_hmatrix(son, tm, eps, recursive); } leafs += son->rsons * son->csons; } } update_hmatrix(G); } else { /* matrix is a leaf -> northing to do */ return; } if (leafs > 0) { /* matrix has sons which are not leafs -> nothing to do */ return; } else { if (G->rc == G->cc) { return; } /* determine ranksum and size of sons */ ranksum = 0; sizeold = 0; for (j = 0; j < csons; ++j) { for (i = 0; i < rsons; ++i) { son = G->son[i + j * rsons]; if (son->r) { ranksum += son->r->k; sizeold += getsize_rkmatrix(son->r); } else { assert(son->f != NULL); ranksum += son->f->cols; sizeold += getsize_amatrix(son->f); } } } /* new rank-k-matrix */ R = new_rkmatrix(G->rc->size, G->cc->size, ranksum); A = &R->A; B = &R->B; clear_amatrix(A); clear_amatrix(B); /* copy sons into a big rank-k-matrix */ rankoffset = 0; coloffset = 0; for (j = 0; j < csons; ++j) { rowoffset = 0; for (i = 0; i < rsons; ++i) { son = G->son[i + j * rsons]; rank = son->r ? son->r->k : son->f->cols; init_sub_amatrix(&T, A, son->rc->size, rowoffset, rank, rankoffset); init_sub_amatrix(&S, B, son->cc->size, coloffset, rank, rankoffset); if (son->r) { copy_amatrix(false, &(son->r->A), &T); copy_amatrix(false, &(son->r->B), &S); } else { copy_amatrix(false, son->f, &T); identity_amatrix(&S); } rankoffset += rank; rowoffset += son->rc->size; uninit_amatrix(&T); uninit_amatrix(&S); } coloffset += G->son[j * rsons]->cc->size; } /* compression */ trunc_rkmatrix(tm, eps, R); sizenew = getsize_rkmatrix(R); /* use new rank-k-matrix or discard */ if (sizenew < sizeold) { for (j = 0; j < csons; ++j) { for (i = 0; i < rsons; ++i) { unref_hmatrix(G->son[i + j * rsons]); } } G->rsons = 0; G->csons = 0; freemem(G->son); G->son = NULL; G->f = NULL; G->r = R; G->desc = 1; } else { del_rkmatrix(R); } } }