/** * @brief build the BDS header * * The header is a 52 byte string with the data type info and 3 * dimensions. The string must be correcly terminated by the null * character (in the 52 bytes) and its content readable with a * C scanf() function using the formatting string "%s%lu%lu%lu". * * Currently, the data type info can only be "flt" for floats. There * is no point using the full C type names since this string won't be * processed as a C code fragment and unsigned types would require two * words, so we use compact abbreviations. "flt" is the standard C * abbreviation for floats (see float.h macros). * * The header length is sufficient for 3x 2**32 dimensions; the * dimensions are checked and this function will abort() if the array * size can't fit into the header length. * * @param nx ny nc array dimensions * @return freshly allocated string pointer */ static char *_io_bds_hdr(size_t nx, size_t ny, size_t nc) { char *hdr; int len; /* empty header fille with spaces */ hdr = _IO_BDS_SAFE_MALLOC(_IO_BDS_HDR_LEN, char); memset(hdr, ' ', _IO_BDS_HDR_LEN); /* check length */ if (1 /* leading space */ + strlen("flt") + 1 /* "flt" data type info + space */ + ndigits(nx) + 1 + ndigits(ny) + 1 + ndigits(nc) + 1 /* ending '\0' */ > _IO_BDS_HDR_LEN) _IO_BDS_ABORT("array dimensions too large for the header format"); /* inhibit splint, already checked for overflow */ /*@-bufferoverflowhigh@ */ len = sprintf(hdr, " %s %lu %lu %lu", "flt", nx, ny, nc); /*@=bufferoverflowhigh@ */ /* terminate at the end of the string */ hdr[len] = ' '; hdr[_IO_BDS_HDR_LEN - 1] = '\0'; return hdr; }
int ispandigital(int m2) { for (int m0 = 1; m0 < ceil(sqrt(m2)); ++m0) { int m1; if (m2 % m0 != 0) continue; m1 = m2 / m0; if (ndigits(m0) + ndigits(m1) + ndigits(m2) != 9) continue; if (sdigits(sdigits(sdigits(0, m0), m1), m2) == SD_ALL) { /* printf("bing! %d * %d = %d\n", m0, m1, m2); */ return 1; } } return 0; }
void SelectLevelScreen::key_down(const KeyDownEvent& event) { switch (_state) { case SELECTING: switch (event.key()) { case Keys::K8: case Keys::N_TIMES: _state = UNLOCKING; _unlock_chapter = 0; _unlock_digits = ndigits(plug.levels.size()); sys.sound.cloak_on(); return; } case UNLOCKING: { int digit = key_digit(event.key()); if (digit < 0) { _state = SELECTING; break; } _unlock_chapter = (_unlock_chapter * 10) + digit; if (--_unlock_digits == 0) { _state = SELECTING; if (_unlock_chapter > plug.levels.size()) { return; } sys.sound.cloak_off(); Ledger::ledger()->unlock_chapter(_unlock_chapter); Ledger::ledger()->unlocked_chapters(&_chapters); adjust_interface(); } return; } break; case FADING_OUT: return; } InterfaceScreen::key_down(event); }
int ispandigital(int n) { int d = ndigits(n); unsigned int sd = sdigits(0, n); for (int i = 1; i <= d; ++i) if (!(sd & (1 << i))) return 0; return 1; }
// compute ||A - Q*T*Q.T|| int test_mult_trd(int M, int N, int lb, int verbose, int flags) { armas_x_dense_t A0, A1, tau0, T0, T1, e1, e2, d1, d2; armas_conf_t conf = *armas_conf_default(); int ok; DTYPE nrm; char *uplo = flags & ARMAS_UPPER ? "UPPER" : "LOWER"; armas_x_init(&A0, N, N); armas_x_init(&A1, N, N); armas_x_init(&T0, N, N); armas_x_init(&T1, N, N); armas_x_init(&tau0, N, 1); // set source data armas_x_set_values(&A0, unitrand, flags); armas_x_mcopy(&A1, &A0); conf.lb = lb; armas_x_trdreduce(&A0, &tau0, flags, &conf); // make tridiagonal matrix T0 armas_x_diag(&d1, &A0, 0); armas_x_diag(&d2, &T0, 0); armas_x_mcopy(&d2, &d1); if (flags & ARMAS_UPPER) { armas_x_diag(&e1, &A0, 1); } else { armas_x_diag(&e1, &A0, -1); } // copy off-diagonals armas_x_diag(&e2, &T0, 1); armas_x_mcopy(&e2, &e1); armas_x_diag(&e2, &T0, -1); armas_x_mcopy(&e2, &e1); // compute Q*T*Q.T armas_x_trdmult(&T0, &A0, &tau0, flags|ARMAS_LEFT, &conf); armas_x_trdmult(&T0, &A0, &tau0, flags|ARMAS_RIGHT|ARMAS_TRANS, &conf); // make result triangular (original matrix) armas_x_make_trm(&T0, flags); nrm = rel_error((DTYPE *)0, &T0, &A1, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = isFINE(nrm, N*__ERROR); printf("%s: [%s] Q*T*Q.T == A\n", PASS(ok), uplo); if (verbose > 0) { printf(" || rel error ||: %e [%d]\n", nrm, ndigits(nrm)); } armas_x_release(&A0); armas_x_release(&A1); armas_x_release(&tau0); armas_x_release(&T0); armas_x_release(&T1); return ok; }
int test_reduce(int M, int N, int lb, int verbose, int flags) { armas_x_dense_t A0, A1, tau0, tau1; armas_conf_t conf = *armas_conf_default(); int ok; char uplo = flags & ARMAS_LOWER ? 'L' : 'U'; DTYPE n0, n1; armas_x_init(&A0, N, N); armas_x_init(&A1, N, N); armas_x_init(&tau0, N, 1); armas_x_init(&tau1, N, 1); // set source data armas_x_set_values(&A0, unitrand, flags); armas_x_mcopy(&A1, &A0); conf.lb = 0; armas_x_trdreduce(&A0, &tau0, flags, &conf); conf.lb = lb; armas_x_trdreduce(&A1, &tau1, flags, &conf); n0 = rel_error((DTYPE *)0, &A0, &A1, ARMAS_NORM_ONE, ARMAS_NONE, &conf); n1 = rel_error((DTYPE *)0, &tau0, &tau1, ARMAS_NORM_TWO, ARMAS_NONE, &conf); ok = isFINE(n0, N*__ERROR); printf("%s: unblk.TRD(A,%c) == blk.TRD(A,%c)\n", PASS(ok), uplo, uplo); if (verbose > 0) { printf(" || error.TRD(A,%c)||: %e [%d]\n", uplo, n0, ndigits(n0)); printf(" || error.tau|| : %e [%d]\n", n1, ndigits(n1)); } armas_x_release(&A0); armas_x_release(&A1); armas_x_release(&tau0); armas_x_release(&tau1); return ok; }
/* ----------------------------------------------------------------------------------- * Test 6: Q(qr(A)).T * Q(qr(A)) == I * OK: ||I - Q.T*Q||_1 ~~ n*eps */ int test_build_identity(int M, int N, int K, int lb, int verbose) { char *blk = lb > 0 ? " blk" : "unblk"; char ct = M == K ? 'M' : 'K'; armas_x_dense_t A0, C0, tau0, D; int ok; DTYPE n0; armas_conf_t conf = *armas_conf_default(); armas_x_init(&A0, M, N); armas_x_init(&C0, M, M); armas_x_init(&tau0, imin(M, N), 1); // set source data armas_x_set_values(&A0, unitrand, ARMAS_ANY); // factorize conf.lb = lb; armas_x_rqfactor(&A0, &tau0, &conf); // compute Q = buildQ(rq(A)), K first columns conf.lb = lb; if (armas_x_rqbuild(&A0, &tau0, K, &conf) < 0) printf("build error: %d\n", conf.error); // C0 = Q.T*Q - I armas_x_mult(0.0, &C0, 1.0, &A0, &A0, ARMAS_TRANSB, &conf); armas_x_diag(&D, &C0, 0); armas_x_add(&D, -1.0, &conf); n0 = armas_x_mnorm(&C0, ARMAS_NORM_ONE, &conf); ok = isOK(n0, N); printf("%s: %s Q(rq(A),%c).T * Q(rq(A),%c) == I\n", PASS(ok), blk, ct, ct); if (verbose > 0) { printf(" || rel error ||_1: %e [%d]\n", n0, ndigits(n0)); } //armas_x_release(&A0); armas_x_release(&C0); armas_x_release(&tau0); return ok; }
/* ----------------------------------------------------------------------------------- * Test 5: unblk.Q(rq(A)) == blk.Q(rq(A)) * OK: ||unblk.Q(rq(A)) - blk.Q(rq(A))||_1 ~~ n*eps */ int test_build(int M, int N, int K, int lb, int verbose) { char ct = N == K ? 'N' : 'K'; armas_x_dense_t A0, A1, tau0; int ok; DTYPE n0; armas_conf_t conf = *armas_conf_default(); armas_x_init(&A0, M, N); armas_x_init(&A1, M, N); armas_x_init(&tau0, imin(M, N), 1); // set source data armas_x_set_values(&A0, unitrand, ARMAS_ANY); // factorize conf.lb = lb; armas_x_rqfactor(&A0, &tau0, &conf); armas_x_mcopy(&A1, &A0); // compute Q = buildQ(rq(A)) conf.lb = 0; armas_x_rqbuild(&A0, &tau0, K, &conf); conf.lb = lb; armas_x_rqbuild(&A1, &tau0, K, &conf); // ||A1 - A0||/||A0|| n0 = rel_error((DTYPE *)0, &A1, &A0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = isOK(n0, N); printf("%s: unblk.Q(rq(A),%c) == blk.Q(rq(A),%c)\n", PASS(ok), ct, ct); if (verbose > 0) { printf(" || rel_error ||_1: %e [%d]\n", n0, ndigits(n0)); } armas_x_release(&A0); armas_x_release(&A1); armas_x_release(&tau0); return ok; }
int test_build(int M, int N, int lb, int K, int verbose, int flags) { armas_x_dense_t A0, tauq0, d0, QQt; armas_conf_t conf = *armas_conf_default(); int ok; DTYPE nrm; int tN = M < N ? M : N; char *uplo = flags & ARMAS_UPPER ? "UPPER" : "LOWER"; armas_x_init(&A0, N, N); armas_x_init(&tauq0, tN, 1); //------------------------------------------------------ // set source data armas_x_set_values(&A0, unitrand, flags); // reduce to tridiagonal matrix conf.lb = lb; armas_x_trdreduce(&A0, &tauq0, flags, &conf); // ---------------------------------------------------------------- // Q-matrix armas_x_trdbuild(&A0, &tauq0, K, flags, &conf); armas_x_init(&QQt, N, N); armas_x_mult(0.0, &QQt, 1.0, &A0, &A0, ARMAS_TRANSB, &conf); armas_x_diag(&d0, &QQt, 0); armas_x_madd(&d0, -1.0, ARMAS_NONE); nrm = armas_x_mnorm(&QQt, ARMAS_NORM_ONE, &conf); ok = isFINE(nrm, N*__ERROR); printf("%s: [%s] I == Q*Q.T\n", PASS(ok), uplo); if (verbose > 0) { printf(" || rel error ||: %e [%d]\n", nrm, ndigits(nrm)); } //------------------------------------------------------ armas_x_release(&A0); armas_x_release(&tauq0); armas_x_release(&QQt); return ok; }
size_t max_formatted_length(T x) const noexcept { size_t n = ndigits(x, base_); if (x < 0 || any(showpos)) n++; return n; }
// test2: M > N and A, U are M-by-M, V = N-by-N int test2(int M, int N, int verbose) { armas_x_dense_t A, S, Sg, U, U1, V, V1, A0, A1, sD; armas_conf_t conf = *armas_conf_default(); DTYPE n0, n1, n2, nrm_A; int err, ok; if (M < N) { printf("%s [M=%d, N=%d]: test2 requires M >= N\n", PASS(0), M, N); return 0; } armas_x_init(&A, M, N); armas_x_init(&A0, M, N); armas_x_init(&A1, M, N); armas_x_init(&U, M, M); armas_x_init(&U1, M, M); armas_x_init(&V, N, N); armas_x_init(&V1, N, N); armas_x_init(&S, N, 1); armas_x_init(&Sg, M, N); armas_x_set_values(&A, unitrand, ARMAS_ANY); armas_x_set_values(&Sg, zero, ARMAS_ANY); armas_x_mcopy(&A0, &A); nrm_A = armas_x_mnorm(&A, ARMAS_NORM_ONE, &conf); err = armas_x_svd(&S, &U, &V, &A, ARMAS_WANTU|ARMAS_WANTV, &conf); if (err) { //printf("error[%d]: %d\n", err, conf.error); printf("%s [M=%d, N=%d, err=%d,%d]: A == U*S*V.T, U=[m,m], V=[n,n] \n", PASS(0), M, N, err, conf.error); return 0; } // compute: I - U.T*U armas_x_mult(0.0, &U1, 1.0, &U, &U, ARMAS_TRANSA, &conf); armas_x_diag(&sD, &U1, 0); armas_x_madd(&sD, -1.0, ARMAS_ANY); n0 = armas_x_mnorm(&U1, ARMAS_NORM_ONE, &conf); // compute: I - V*V.T armas_x_mult(0.0, &V1, 1.0, &V, &V, ARMAS_TRANSA, &conf); armas_x_diag(&sD, &V1, 0); armas_x_madd(&sD, -1.0, ARMAS_ANY); n1 = armas_x_mnorm(&V1, ARMAS_NORM_ONE, &conf); // compute: A - U*S*V.T == A - U*diag(Sg)*V.T armas_x_diag(&sD, &Sg, 0); armas_x_copy(&sD, &S, &conf); armas_x_mult(0.0, &A1, 1.0, &U, &Sg, ARMAS_NONE, &conf); armas_x_mult(1.0, &A0, -1.0, &A1, &V, ARMAS_NONE, &conf); n2 = armas_x_mnorm(&A0, ARMAS_NORM_ONE, &conf) / nrm_A; ok = isOK(n2, 10*M); printf("%s [M=%d, N=%d]: A == U*S*V.T, U=[m,m], V=[n,n] \n", PASS(ok), M, N); if (verbose > 0) { printf(" ||A - U*S*V.T||_1: %e [%d]\n", n2, ndigits(n2)); printf(" ||I - U.T*U||_1 : %e [%d]\n", n0, ndigits(n0)); printf(" ||I - V*V.T||_1 : %e [%d]\n", n1, ndigits(n1)); } armas_x_release(&A); armas_x_release(&A0); armas_x_release(&A1); armas_x_release(&U); armas_x_release(&U1); armas_x_release(&V); armas_x_release(&V1); armas_x_release(&S); armas_x_release(&Sg); return ok; }
int main(int argc, char **argv) { armas_conf_t conf; armas_x_dense_t B0, A, B; int ok, opt; int N = 301; int verbose = 1; int fails = 0; DTYPE alpha = 1.0; DTYPE n0, n1; while ((opt = getopt(argc, argv, "vC:")) != -1) { switch (opt) { case 'v': verbose++; break; case 'C': Aconstant = STRTOF(optarg); break; default: fprintf(stderr, "usage: trsm [-P nproc] [size]\n"); exit(1); } } if (optind < argc) N = atoi(argv[optind]); conf = *armas_conf_default(); armas_x_init(&A, N, N); armas_x_init(&B, N, N); armas_x_init(&B0, N, N); // Upper triangular matrix armas_x_set_values(&A, one, ARMAS_UPPER); if (N < 10) { printf("A:\n"); armas_x_printf(stdout, "%8.1e", &A); } armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_LEFT, &conf); if (N < 10) { printf("A*B:\n"); armas_x_printf(stdout, "%8.1e", &B); } armas_x_solve_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_LEFT, &conf); if (N < 10) { printf("A.-1*B:\n"); armas_x_printf(stdout, "%8.1e", &B); } n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, L|U|N), A, L|U|N)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_RIGHT, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_RIGHT, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, R|U|N), A, R|U|N)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_LEFT|ARMAS_TRANSA, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_LEFT|ARMAS_TRANSA, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, L|U|T), A, L|U|T)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_RIGHT|ARMAS_TRANSA, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_UPPER|ARMAS_RIGHT|ARMAS_TRANSA, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, R|U|T), A, R|U|T)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; // Lower triangular matrix armas_x_set_values(&A, one, ARMAS_LOWER); armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_LEFT, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_LEFT, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, L|L|N), A, L|L|N)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_RIGHT, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_RIGHT, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, R|L|N), A, R|L|N)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_LEFT|ARMAS_TRANSA, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_LEFT|ARMAS_TRANSA, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, L|L|T), A, L|L|T)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; armas_x_set_values(&B, one, ARMAS_NULL); armas_x_mcopy(&B0, &B); armas_x_mult_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_RIGHT|ARMAS_TRANSA, &conf); armas_x_solve_trm(&B, alpha, &A, ARMAS_LOWER|ARMAS_RIGHT|ARMAS_TRANSA, &conf); n0 = rel_error(&n1, &B, &B0, ARMAS_NORM_ONE, ARMAS_NONE, &conf); ok = n0 == 0.0 || isOK(n0, N) ? 1 : 0; printf("%6s: B = solve_trm(mult_trm(B, A, R|L|T), A, R|L|T)\n", PASS(ok)); if (verbose > 0) { printf(" || rel error || : %e, [%d]\n", n0, ndigits(n0)); } fails += 1 - ok; test_left_right(N, verbose); exit(fails); }
/*ARGSUSED*/ void print_partition(struct partition_info *pinfo, int partnum, int want_header) { int i; blkaddr_t nblks; int cyl1; int cyl2; float scaled; int maxcyl2; int ncyl2_digits; char *s; blkaddr_t maxnblks = 0; blkaddr_t len; /* * To align things nicely, we need to know the maximum * width of the number of cylinders field. */ maxcyl2 = 0; for (i = 0; i < NDKMAP; i++) { nblks = (uint_t)pinfo->pinfo_map[i].dkl_nblk; cyl1 = pinfo->pinfo_map[i].dkl_cylno; cyl2 = cyl1 + (nblks / spc()) - 1; if (nblks > 0) { maxcyl2 = max(cyl2, maxcyl2); maxnblks = max(nblks, maxnblks); } } /* * Get the number of digits required */ ncyl2_digits = ndigits(maxcyl2); /* * Print the header, if necessary */ if (want_header) { fmt_print("Part "); fmt_print("Tag Flag "); fmt_print("Cylinders"); nspaces(ncyl2_digits); fmt_print(" Size Blocks\n"); } /* * Print the partition information */ nblks = pinfo->pinfo_map[partnum].dkl_nblk; cyl1 = pinfo->pinfo_map[partnum].dkl_cylno; cyl2 = cyl1 + (nblks / spc()) - 1; fmt_print(" %x ", partnum); /* * Print the partition tag. If invalid, print - */ s = find_string(ptag_choices, (int)pinfo->vtoc.v_part[partnum].p_tag); if (s == (char *)NULL) s = "-"; nspaces(10 - (int)strlen(s)); fmt_print("%s", s); /* * Print the partition flag. If invalid print - */ s = find_string(pflag_choices, (int)pinfo->vtoc.v_part[partnum].p_flag); if (s == (char *)NULL) s = "-"; nspaces(6 - (int)strlen(s)); fmt_print("%s", s); nspaces(2); if (nblks == 0) { fmt_print("%6d ", cyl1); nspaces(ncyl2_digits); fmt_print(" 0 "); } else { fmt_print("%6d - ", cyl1); nspaces(ncyl2_digits - ndigits(cyl2)); fmt_print("%d ", cyl2); scaled = bn2mb(nblks); if (scaled > (float)1024.0 * 1024.0) { fmt_print("%8.2fTB ", scaled/((float)1024.0 * 1024.0)); } else if (scaled > (float)1024.0) { fmt_print("%8.2fGB ", scaled/(float)1024.0); } else { fmt_print("%8.2fMB ", scaled); } } fmt_print("("); pr_dblock(fmt_print, nblks); fmt_print(")"); nspaces(ndigits(maxnblks/spc()) - ndigits(nblks/spc())); /* * Allocates size of the printf format string. * ndigits(ndigits(maxblks)) gives the byte size of * the printf width field for maxnblks. */ len = strlen(" %") + ndigits(ndigits(maxnblks)) + strlen("d\n") + 1; s = zalloc(len); (void) snprintf(s, len, "%s%u%s", " %", ndigits(maxnblks), "u\n"); fmt_print(s, nblks); (void) free(s); }
/*ARGSUSED*/ void print_efi_partition(struct dk_gpt *map, int partnum, int want_header) { int ncyl2_digits = 0; float scaled; char *s; uint64_t secsize; ncyl2_digits = ndigits(map->efi_last_u_lba); if (want_header) { fmt_print("Part "); fmt_print("Tag Flag "); fmt_print("First Sector"); nspaces(ncyl2_digits); fmt_print("Size"); nspaces(ncyl2_digits); fmt_print("Last Sector\n"); } fmt_print(" %d ", partnum); s = find_string(ptag_choices, (int)map->efi_parts[partnum].p_tag); if (s == (char *)NULL) s = "-"; nspaces(10 - (int)strlen(s)); fmt_print("%s", s); s = find_string(pflag_choices, (int)map->efi_parts[partnum].p_flag); if (s == (char *)NULL) s = "-"; nspaces(6 - (int)strlen(s)); fmt_print("%s", s); nspaces(2); secsize = map->efi_parts[partnum].p_size; if (secsize == 0) { fmt_print("%16llu", map->efi_parts[partnum].p_start); nspaces(ncyl2_digits); fmt_print(" 0 "); } else { fmt_print("%16llu", map->efi_parts[partnum].p_start); scaled = bn2mb(secsize); nspaces(ncyl2_digits - 5); if (scaled >= (float)1024.0 * 1024) { fmt_print("%8.2fTB", scaled/((float)1024.0 * 1024)); } else if (scaled >= (float)1024.0) { fmt_print("%8.2fGB", scaled/(float)1024.0); } else { fmt_print("%8.2fMB", scaled); } } nspaces(ncyl2_digits); if ((map->efi_parts[partnum].p_start+secsize - 1) == UINT_MAX64) { fmt_print(" 0 \n"); } else { fmt_print(" %llu \n", map->efi_parts[partnum].p_start+secsize - 1); } }