int main(void) { int i; printf("%016llx\n",pw2(5,0x1ull)); printf("%016llx\n",pop(0x11100ull)); printf("%016llx\n",rev(0x1ull)); printf("%016llx\n",lg2(0x5ull)); return 0; }
static int thresold(uint *h, size_t size) { double prob[256]; size_t min_i = 256; double min_var = DBL_MAX; for (size_t i = 0; i < 256; ++i) prob[i] = (double)h[i] / (double)size; for (size_t j = 1; j < 255; ++j) { double m_under = 0, c = 0; for (size_t k = 0; k < j; ++k) { m_under += k * prob[k]; c += prob[k]; } // next iteration if a class is empty if (c == 0 || c == 1) continue; m_under /= c; double m_up = 0; for (size_t k = j; k < 256; ++k) m_up += k * prob[k]; m_up /= (1 - c); double var = 0; for (size_t k = 0; k < j; ++k) var += pw2(k - m_under) * prob[k]; for (size_t k = j; k < 256; ++k) var += pw2(k - m_up) * prob[k]; if (min_var > var) { min_i = j; min_var = var; } } return min_i; }
void flush_pending_line_to_obj(struct g_part *p, int minheight) { int i, pp, pos, w, lbl; struct g_object_line *l = p->line; struct g_object_area *a; if (!l) { return; } for (i = l->n_entries - 1; i >= 0; i--) { struct g_object_text *go = (struct g_object_text *)l->entries[i]; if (go->draw == g_text_draw) { int l; while ((l = strlen(go->text)) && go->text[l - 1] == ' ') go->text[l - 1] = 0, go->xw -= g_char_width(go->style, ' '); if (go->xw < 0) internal("xw(%d) < 0", go->xw); } if (!go->xw) continue; break; } scan_again: pp = 0; w = minheight; lbl = 0; for (i = 0; i < l->n_entries; i++) { int yy = l->entries[i]->y; if (yy >= G_OBJ_ALIGN_SPECIAL) yy = 0; pp += l->entries[i]->xw; if (l->entries[i]->xw && l->entries[i]->yw + yy > w) w = l->entries[i]->yw + yy; if (yy < lbl) lbl = yy; } if (lbl < 0) { for (i = 0; i < l->n_entries; i++) { if (l->entries[i]->y < G_OBJ_ALIGN_SPECIAL) l->entries[i]->y -= lbl; } goto scan_again; } if (par_format.align == AL_CENTER) pos = (rm(par_format) + par_format.leftmargin * G_HTML_MARGIN - pp) / 2; else if (par_format.align == AL_RIGHT) pos = rm(par_format) - pp; else pos = par_format.leftmargin * G_HTML_MARGIN; if (pos < par_format.leftmargin * G_HTML_MARGIN) pos = par_format.leftmargin * G_HTML_MARGIN; pp = pos; for (i = 0; i < l->n_entries; i++) { l->entries[i]->x = pp; pp += l->entries[i]->xw; if (l->entries[i]->y < G_OBJ_ALIGN_SPECIAL) { l->entries[i]->y = w - l->entries[i]->yw - l->entries[i]->y; } else if (l->entries[i]->y == G_OBJ_ALIGN_TOP) { l->entries[i]->y = 0; } else if (l->entries[i]->y == G_OBJ_ALIGN_MIDDLE) { l->entries[i]->y = (w - l->entries[i]->yw + 1) / 2; } } l->x = 0; l->xw = par_format.width; l->yw = w; l->y = p->cy; if (l->xw > p->root->xw) p->root->xw = l->xw; p->root->yw = p->cy += w; p->root->n_lines++; if ((unsigned)p->root->n_lines > (MAXINT - sizeof(struct g_object_area)) / 2 / sizeof(struct g_object_text *) + 1) overalloc(); a = mem_realloc(p->root, sizeof(struct g_object_area) + sizeof(struct g_object_text *) * pw2(p->root->n_lines + 1)); /* note: +1 is for extend_area */ p->root = a; p->root->lines[p->root->n_lines - 1] = l; p->line = NULL; p->w.pos = 0; p->w.last_wrap = NULL; p->w.last_wrap_obj = NULL; }
int main() { /* For std::unique_ptr, the type of the deleter is part of the type of the * smart pointer. For std::shared_ptr, it's not. */ std::cout << "Part 1: deleter type being part or not" << std::endl; std::unique_ptr< // deleter type is Widget, decltype(loggingDel) // part of ptr type > upw(new Widget, loggingDel); std::shared_ptr<Widget> // deleter type is not spw(new Widget, loggingDel); // part of ptr type /* The std::shared_ptr design is more flexible: the type of the custom deleter * is not part of the shared_ptr type, so the following things are for example * possible: * * -> can be placed in containers of objects of the shared_ptr type * -> they can be assigned to one another * -> they can be passed to a function taking a parameter of * type std::shared_ptr<Widget>. * -> ... * * None of these things can be done with std::unique_ptrs that differ in the * types of their custom deleters, because the type of the custom deleter would * affect the type of the std::unique_ptr. */ std::cout << "Part 2: std::shared_ptr design being more flexible" << std::endl; auto customDeleter1 = [](Widget *pw) { makeLogentry(pw); delete pw; }; // custom deleters, auto customDeleter2 = [](Widget *pw) { makeLogentry(pw); delete pw; }; // each with a // different type std::shared_ptr<Widget> pw1(new Widget, customDeleter1); std::shared_ptr<Widget> pw2(new Widget, customDeleter2); std::vector<std::shared_ptr<Widget>> vpw { pw1, pw2 }; /* * BAD BAD BAD: constructing more than one std::shared_ptr from a single * raw pointer results in undefined behavior. */ std::cout << "Part 3: std::shared_ptr construction error" << std::endl; //auto pw = new Widget; // //std::shared_ptr<Widget> spw1(pw, loggingDel); // create control // // block for *pw // //std::shared_ptr<Widget> spw2(pw, loggingDel); // create 2nd // // control block // // for *pw! std::shared_ptr<Widget> spw1(new Widget, // direct use of new loggingDel); std::shared_ptr<Widget> spw2(spw1); // spw2 uses same // control block as spw1 std::cout << "Part 4: right before end of main" << std::endl; }