static void test_bv_xor(TestCase *tc, void *data)
{
# define XOR_SIZE 1000
static const int xor_cnt = 500;
BitVector *xor_bv;
BitVector *bv1 = bv_new();
BitVector *bv2 = bv_new();
char set[XOR_SIZE];
char set1[XOR_SIZE];
char set2[XOR_SIZE];
int i;
int count = 0;
(void)data;
memset(set, 0, XOR_SIZE);
memset(set1, 0, XOR_SIZE);
memset(set2, 0, XOR_SIZE);
for (i = 0; i < xor_cnt; i++) {
int bit = rand() % XOR_SIZE;
bv_set(bv1, bit);
set1[bit] = 1;
}
for (i = 0; i < xor_cnt; i++) {
int bit = rand() % XOR_SIZE;
bv_set(bv2, bit);
set2[bit] = 1;
}
for (i = 0; i < XOR_SIZE; i++) {
if (set1[i] != set2[i]) {
set[i] = 1;
count++;
}
}
xor_bv = bv_xor(bv1, bv2);
Aiequal(count, xor_bv->count);
for (i = 0; i < XOR_SIZE; i++) {
if (!Aiequal(set[i], bv_get(xor_bv, i))) {
Tmsg("At position %d, bv1 is %d and bv2 is %d\n", i,
bv_get(bv1, i), bv_get(bv2, i));
}
}
bv1 = bv_xor_x(bv1, bv2);
Assert(bv_eq(bv1, xor_bv), "BitVectors should be equal");
bv_destroy(bv2);
bv_destroy(xor_bv);
bv2 = bv_new();
xor_bv = bv_xor(bv1, bv2);
Assert(bv_eq(bv1, xor_bv), "XORed BitVector equals bv1");
bv_destroy(bv1);
bv_destroy(bv2);
bv_destroy(xor_bv);
}
static void sim_handle_cmd(struct simulator *sim, struct cmd *cmd) {
struct signal *signal;
PRINT_CMD("CMD %s", cmd_names[cmd->type]);
switch (cmd->type) {
case CMD_ECHO:
PRINT_CMD(" arg=%s", cmd->data.echo.arg);
break;
case CMD_TIME:
PRINT_CMD(" picos=%" PICO, cmd->data.time.picos);
sim->picos = cmd->data.time.picos;
break;
case CMD_VALUE:
signal = cmd->data.value.signal;
PRINT_CMD(" signal %s set to '%s' at %" PICO " ps", signal->name, cmd->data.value.value, cmd->data.value.time.picos);
if (bv_get(&sim->events, signal->index)) {
PRINT_CMD("Signal %s set multiple times during time %" PICO " = %s -> %s \n",
signal->name, cmd->data.value.time.picos, signal->value, cmd->data.value.value);
}
signal_set_value(signal, cmd->data.value.value);
sim->picos = cmd->data.value.time.picos;
signal->event = 1;
bv_set(&sim->events, signal->index, 1);
sim->any_event = 1;
break;
case CMD_READ:
signal = cmd->data.read.signal;
PRINT_CMD(" %s read '%s'", signal->name, cmd->data.read.value);
signal_set_value(signal, cmd->data.read.value);
break;
}
PRINT_CMD("\n");
}
static bool fqsc_next(Scorer *self)
{
Scorer *sub_sc = FQSc(self)->sub_scorer;
BitVector *bv = FQSc(self)->bv;
while (sub_sc->next(sub_sc)) {
self->doc = sub_sc->doc;
if (bv_get(bv, self->doc)) return true;
}
return false;
}
static void test_bv_not(TestCase *tc, void *data)
{
BitVector *bv = bv_new(), *not_bv;
int i;
(void)data;
set_bits(bv, "1, 5, 25, 41, 97, 185");
Aiequal(186, bv->size);
not_bv = bv_not(bv);
Aiequal(bv->count, not_bv->count);
for (i = 0; i < 300; i++) {
Aiequal(1 - bv_get(bv, i), bv_get(not_bv, i));
}
bv_not_x(bv);
Assert(bv_eq(bv, not_bv), "BitVectors equal");
bv_destroy(bv);
bv_destroy(not_bv);
}
/*
* call-seq:
* bv.get(i) -> bool
* bv[i] -> bool
*
* Get the bit value at _i_
*/
VALUE
frt_bv_get(VALUE self, VALUE rindex)
{
BitVector *bv;
int index = FIX2INT(rindex);
GET_BV(bv, self);
if (index < 0) {
rb_raise(rb_eIndexError, "%d < 0", index);
}
return bv_get(bv, index) ? Qtrue : Qfalse;
}
exprt boolbvt::bv_get_cache(const exprt &expr) const
{
if(expr.type().id()==ID_bool) // boolean?
return get(expr);
// look up literals in cache
bv_cachet::const_iterator it=bv_cache.find(expr);
if(it==bv_cache.end())
return nil_exprt();
return bv_get(it->second, expr.type());
}
static void test_bv_or(TestCase *tc, void *data)
{
# define OR_SIZE 1000
static const int or_cnt = 500;
BitVector *or_bv;
BitVector *bv1 = bv_new();
BitVector *bv2 = bv_new();
char set[OR_SIZE];
int i;
int count = 0;
(void)data;
memset(set, 0, OR_SIZE);
for (i = 0; i < or_cnt; i++) {
int bit = rand() % OR_SIZE;
bv_set(bv1, bit);
if (0 == set[bit]) {
count++;
set[bit] = 1;
}
}
for (i = 0; i < or_cnt; i++) {
int bit = rand() % OR_SIZE;
bv_set(bv2, bit);
if (0 == set[bit]) {
count++;
set[bit] = 1;
}
}
or_bv = bv_or(bv1, bv2);
Aiequal(count, or_bv->count);
for (i = 0; i < OR_SIZE; i++) {
Aiequal(set[i], bv_get(or_bv, i));
}
bv1 = bv_or_x(bv1, bv2);
Assert(bv_eq(bv1, or_bv), "BitVectors should be equal");
bv_destroy(bv2);
bv_destroy(or_bv);
bv2 = bv_new();
or_bv = bv_or(bv1, bv2);
Assert(bv_eq(bv1, or_bv), "ORed BitVector equals bv1");
bv_destroy(bv1);
bv_destroy(bv2);
bv_destroy(or_bv);
}
static bool fqsc_skip_to(Scorer *self, int doc_num)
{
Scorer *sub_sc = FQSc(self)->sub_scorer;
BitVector *bv = FQSc(self)->bv;
if (sub_sc->skip_to(sub_sc, doc_num)) {
do {
self->doc = sub_sc->doc;
if (bv_get(bv, self->doc)) {
return true;
}
} while (sub_sc->next(sub_sc));
}
return false;
}
int main(int argc, char **argv) {
CJOB *settings = get_settings(argc, argv);
if(DEBUG_LEVEL >= 1) print_commet_job(settings);
int i = 0, j = 0;
int n = settings->num_sets;
char *sfafname = settings->sets[0]->filenames[0];
char *sbvfname = get_bvfname_from_one_fafname(settings, sfafname);
READSET *set_b = settings->sets[1];
BITVEC *uniq = reads_not_in_set(settings, sfafname, sbvfname, set_b);
for(i = 2; i < settings->num_sets; i++) {
set_b = settings->sets[i];
BITVEC *uniq2 = reads_not_in_set(settings, sfafname, sbvfname, set_b);
bv_iand(uniq, uniq2);
}
bv_save_to_file(uniq, "uniq.bv");
for(i = 0; i < uniq->num_bits / CHAR_BIT; i++) {
printf("%i", bv_get(uniq, i));
if(i % 100 == 0) puts("");
}
puts("");
extract_reads(sfafname, "uniq.bv", "uniq.fasta");
cjob_destroy(settings);
return 0;
}
static int draw_edge_overlay()
{
int shutter_fullpress = kbd_is_key_pressed(KEY_SHOOT_FULL);
int x, y;
int x_off, y_off;
const color cl = FG_COLOR(user_color(conf.edge_overlay_color));
const int y_slice_min = camera_screen.edge_hmargin+ slice *slice_height;
const int y_slice_max = camera_screen.edge_hmargin+(slice+1)*slice_height;
const int y_min = camera_screen.edge_hmargin;
const int y_max = camera_screen.edge_hmargin+viewport_height;
const int x_min = 2;
const int x_max = (viewport_width - 2);
if( !is_buffer_ready() ) return 0;
for (y = y_slice_min; y < y_slice_max; ++y)
{
y_off = y + yoffset;
shutter_fullpress |= kbd_is_key_pressed(KEY_SHOOT_FULL);
if ((unsigned)(y_off-y_min) < (y_max-y_min)) // is the same as ((y_off > y_min) && (y_off < y_max)) // do not draw outside of allowed area
{
const int y_edgebuf = (y-y_min) * viewport_width;
for (x = x_min; x < x_max; ++x)
{
x_off = x + xoffset;
if ((unsigned)(x_off-x_min) < (x_max-x_min)) // is the same as ((x_off > x_min) && (x_off < x_max)) // do not draw outside of allowed area
{
// Draw a pixel to the screen wherever we detected an edge.
// If there is no edge based on the newest data, but there is one painted on the screen
// from previous calls, delete it from the screen.
const int bEdge = bv_get(edgebuf, y_edgebuf + x);
const int bDraw = bEdge || (draw_get_pixel_unrotated(x_off+viewport_xoffset, y_off+viewport_yoffset) == cl);
if (bEdge || bDraw)
draw_pixel_unrotated(x_off+viewport_xoffset, y_off+viewport_yoffset, bEdge ? cl : 0);
}
} // for x
}
} // for y
// Drawing the overlay is over.
// But as a finishing touch we clear up garbage on the screen
// by clearing those parts that the overlay has left.
if (xoffset != 0)
{
// Cleans up leftover from horizontal motion
const int x_min_c = (xoffset < 0) ? x_max + xoffset : x_min;
const int x_max_c = (xoffset > 0) ? x_min + xoffset : x_max;
for (y = y_min; y < y_max; ++y)
{
for (x = x_min_c; x < x_max_c; ++x)
{
// if there is an edge drawn on the screen but there is no edge there based on the newest data, delete it from the screen
if (draw_get_pixel_unrotated(x+viewport_xoffset, y+viewport_yoffset) == cl)
draw_pixel_unrotated(x+viewport_xoffset, y+viewport_yoffset, 0 );
}
}
}
if (yoffset != 0)
{
// Cleans up leftover from vertical motion
const int y_min_c = (yoffset < 0) ? y_max + yoffset : y_min;
const int y_max_c = (yoffset > 0) ? y_min + yoffset : y_max;
for (y = y_min_c; y < y_max_c; ++y)
{
for (x = x_min; x < x_max; ++x)
{
// if there is an edge drawn on the screen but there is no edge there based on the newest data, delete it from the screen
if (draw_get_pixel_unrotated(x+viewport_xoffset, y+viewport_yoffset) == cl)
draw_pixel_unrotated(x+viewport_xoffset, y+viewport_yoffset, 0 );
}
}
}
return shutter_fullpress;
}
/**
* Stress test BitVector Scanning as well as bv_set_fast. This test has been
* run successfully with BV_DENSE_SCAN_SIZE set to 20000000 and BV_SCAN_INC
* set to 97. When running this test with high numbers, be sure use -q on the
* command line or the test will take a very long time.
*/
static void test_bv_scan_stress(TestCase *tc, void *data)
{
int i;
BitVector *bv = bv_new_capa(BV_SCAN_SIZE);
BitVector *not_bv;
(void)data; /* suppress unused argument warning */
for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) {
bv_set_fast(bv, i);
Aiequal(bv_get(bv, i), 1);
Aiequal(bv_get(bv, i-1), 0);
Aiequal(bv_get(bv, i+1), 0);
}
not_bv = bv_not(bv);
for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) {
Aiequal(i, bv_scan_next_from(bv, i - BV_SCAN_INC / 2));
Aiequal(i, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2));
}
Aiequal(-1, bv_scan_next_from(bv, i - BV_SCAN_INC / 2));
Aiequal(-1, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2));
/* test scan_next_from where size is actually greater than the highest set
* bit */
bv_unset(bv, bv->size);
bv_set(not_bv, not_bv->size);
bv_scan_reset(bv);
bv_scan_reset(not_bv);
for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) {
Aiequal(i, bv_scan_next_from(bv, i - BV_SCAN_INC / 2));
Aiequal(i, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2));
}
Aiequal(-1, bv_scan_next_from(bv, i - BV_SCAN_INC / 2));
Aiequal(-1, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2));
bv_scan_reset(bv);
bv_scan_reset(not_bv);
for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) {
Aiequal(i, bv_scan_next(bv));
Aiequal(i, bv_scan_next_unset(not_bv));
}
Aiequal(-1, bv_scan_next(bv));
Aiequal(-1, bv_scan_next_unset(not_bv));
bv_clear(bv);
bv_destroy(not_bv);
for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) {
bv_set(bv, i);
}
not_bv = bv_not(bv);
for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) {
Aiequal(i, bv_scan_next_from(bv, i));
Aiequal(i, bv_scan_next_unset_from(not_bv, i));
}
Aiequal(-1, bv_scan_next_from(bv, i));
Aiequal(-1, bv_scan_next_unset_from(not_bv, i));
bv_scan_reset(bv);
bv_scan_reset(not_bv);
for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) {
Aiequal(i, bv_scan_next(bv));
Aiequal(i, bv_scan_next_unset(not_bv));
}
Aiequal(-1, bv_scan_next(bv));
Aiequal(-1, bv_scan_next_unset(not_bv));
bv_destroy(bv);
bv_destroy(not_bv);
}
/**
* Test basic BitVector get/set/unset operations
*/
static void test_bv(TestCase *tc, void *data)
{
int i;
BitVector *bv = bv_new();
(void)data; /* suppress unused argument warning */
Aiequal(0, bv->size);
Aiequal(0, bv->count);
Aiequal(0, bv_recount(bv));
bv_set(bv, 10);
Aiequal(1, bv_get(bv, 10));
Aiequal(11, bv->size);
Aiequal(1, bv->count);
Aiequal(1, bv_recount(bv));
bv_set(bv, 10);
Aiequal(1, bv_get(bv, 10));
Aiequal(11, bv->size);
Aiequal(1, bv->count);
Aiequal(1, bv_recount(bv));
bv_set(bv, 20);
Aiequal(1, bv_get(bv, 20));
Aiequal(21, bv->size);
Aiequal(2, bv->count);
Aiequal(2, bv_recount(bv));
bv_unset(bv, 21);
Aiequal(0, bv_get(bv, 21));
Aiequal(22, bv->size);
Aiequal(2, bv->count);
Aiequal(2, bv_recount(bv));
bv_unset(bv, 20);
Aiequal(0, bv_get(bv, 20));
Aiequal(22, bv->size);
Aiequal(1, bv->count);
Aiequal(1, bv_recount(bv));
Aiequal(1, bv_get(bv, 10));
bv_set(bv, 100);
Aiequal(1, bv_get(bv, 100));
Aiequal(101, bv->size);
Aiequal(2, bv->count);
Aiequal(2, bv_recount(bv));
Aiequal(1, bv_get(bv, 10));
bv_clear(bv);
Aiequal(0, bv_get(bv, 10));
Aiequal(0, bv->size);
Aiequal(0, bv->count);
Aiequal(0, bv_recount(bv));
bv_unset(bv, 20);
Aiequal(21, bv->size);
/* test setting bits at intervals for a large number of bits */
bv_clear(bv);
for (i = BV_INT; i < BV_SIZE; i += BV_INT) {
bv_set(bv, i);
}
for (i = BV_INT; i < BV_SIZE; i += BV_INT) {
Aiequal(1, bv_get(bv, i));
Aiequal(0, bv_get(bv, i - 1));
Aiequal(0, bv_get(bv, i + 1));
}
/* test setting all bits */
bv_clear(bv);
for (i = 0; i < BV_SIZE; i++) {
bv_set(bv, i);
}
for (i = 0; i < BV_SIZE; i++) {
Aiequal(1, bv_get(bv, i));
}
/* test random bits */
bv_clear(bv);
for (i = 0; i < BV_SIZE; i++) {
if ((rand() % 2) == 0) {
bv_set(bv, i);
Aiequal(1, bv_get(bv, i));
}
}
bv_destroy(bv);
}
static void test_bv_and(TestCase *tc, void *data)
{
# define AND_SIZE 1000
static const int and_cnt = 500;
BitVector *and_bv;
BitVector *bv1 = bv_new();
BitVector *bv2 = bv_new();
BitVector *not_bv1, *not_bv2, *or_bv, *not_and_bv;
char set1[AND_SIZE];
char set2[AND_SIZE];
int i;
int count = 0;
(void)data;
memset(set1, 0, AND_SIZE);
memset(set2, 0, AND_SIZE);
for (i = 0; i < and_cnt; i++) {
int bit = rand() % AND_SIZE;
bv_set(bv1, bit);
set1[bit] = 1;
}
for (i = 0; i < and_cnt; i++) {
int bit = rand() % AND_SIZE;
bv_set(bv2, bit);
if (1 == set1[bit] && !set2[bit]) {
count++;
set2[bit] = 1;
}
}
not_bv1 = bv_not(bv1); not_bv2 = bv_not(bv2);
and_bv = bv_and(not_bv1, not_bv2);
not_and_bv = bv_not(and_bv);
or_bv = bv_or(bv1, bv2);
Assert(bv_eq(not_and_bv, or_bv), "BitVectors should be equal");
bv_destroy(not_bv1); bv_destroy(not_bv2);
bv_destroy(and_bv);
bv_destroy(not_and_bv);
bv_destroy(or_bv);
and_bv = bv_and(bv1, bv2);
Aiequal(count, and_bv->count);
for (i = 0; i < AND_SIZE; i++) {
Aiequal(set2[i], bv_get(and_bv, i));
}
bv1 = bv_and_x(bv1, bv2);
Assert(bv_eq(bv1, and_bv), "BitVectors should be equal");
bv_destroy(bv2);
bv_destroy(and_bv);
bv2 = bv_new();
and_bv = bv_and(bv1, bv2);
Assert(bv_eq(bv2, and_bv), "ANDed BitVector should be empty");
bv_destroy(bv1);
bv_destroy(bv2);
bv_destroy(and_bv);
bv1 = bv_new();
bv_not_x(bv1);
bv2 = bv_new();
bv_set(bv2, 10);
bv_set(bv2, 11);
bv_set(bv2, 20);
and_bv = bv_and(bv1, bv2);
Assert(bv_eq(bv2, and_bv), "ANDed BitVector should be equal");
bv_destroy(bv1);
bv_destroy(bv2);
bv_destroy(and_bv);
}
