ferret 0.9.6 → 0.10.0

data/ext/bitvector.c

@@ -1,168 +1,526 @@
-#include <bitvector.h>
+#include "bitvector.h"
 #include <string.h>
 
-BitVector *bv_create_size(int size)
+BitVector *bv_new_capa(int capa)
 {
-  BitVector *bv = ALLOC(BitVector);
+    BitVector *bv = ALLOC(BitVector);
 
-  bv->capa = (size >> 3) + 1;
-  bv->bits = ALLOC_N(uchar, bv->capa);
-  memset(bv->bits, 0, bv->capa);
+    /* The capacity passed by the user is number of bits allowed, however we
+     * store capacity as the number of words (U32) allocated. */
+    bv->capa = (capa >> 5) + 1;
+    bv->bits = ALLOC_AND_ZERO_N(f_u32, bv->capa);
 
-  bv->size = 0;
-  bv->count = 0;
-  bv->curr_bit = -1;
-  return bv;
+    bv->size = 0;
+    bv->count = 0;
+    bv->curr_bit = -1;
+    bv->extends_as_ones = 0;
+    return bv;
 }
 
-BitVector *bv_create()
+BitVector *bv_new()
 {
-  return bv_create_size(BV_INIT_CAPA);
+    return bv_new_capa(BV_INIT_CAPA);
 }
 
-void bv_destroy(BitVector *bv)
+void bv_destroy(BitVector * bv)
 {
-  free(bv->bits);
-  free(bv);
+    free(bv->bits);
+    free(bv);
 }
 
-void bv_set(BitVector *bv, int bit)
+void bv_set(BitVector * bv, int bit)
 {
-  uchar *byte_p;
-  int byte = bit>>3;
-  uchar bitmask = 1<<(bit&7);
-  if (bv->size <= byte) {
-    bv->size = byte + 1;
-    if (bv->size >= bv->capa) {
-      int capa = bv->capa * 2;
-      while (capa < bv->size) capa *= 2;
-      REALLOC_N(bv->bits, uchar, capa);
-      memset(bv->bits + bv->capa, 0, capa - bv->capa);
-      bv->capa = capa;
+    f_u32 *word_p;
+    int word = bit >> 5;
+    f_u32 bitmask = 1 << (bit & 31);
+    
+    /* Check to see if we need to grow the BitVector */
+    if (bit >= bv->size) {
+        bv->size = bit + 1; /* size is max range of bits set */
+        if (word >= bv->capa) {
+            int capa = bv->capa << 1;
+            while (capa <= word) {
+                capa <<= 1;
+            }
+            REALLOC_N(bv->bits, f_u32, capa);
+            memset(bv->bits + bv->capa, (bv->extends_as_ones ? 0xFF : 0),
+                   sizeof(f_u32) * (capa - bv->capa));
+            bv->capa = capa;
+        }
     }
-  }
-  byte_p = &(bv->bits[byte]);
-  if ((bitmask & *byte_p) == 0) {
+    
+    /* Set the required bit */
+    word_p = &(bv->bits[word]);
+    if ((bitmask & *word_p) == 0) {
+        bv->count++; /* update count */
+        *word_p |= bitmask;
+    }
+}
+
+/*
+ * This method relies on the fact that enough space has been set for the bits
+ * to be set. You need to create the BitVector using bv_new_capa(capa) with
+ * a capacity larger than any bit being set.
+ */
+void bv_set_fast(BitVector * bv, int bit)
+{
     bv->count++;
-    *byte_p |= bitmask;
-  }
+    bv->size = bit;
+    bv->bits[bit >> 5] |= 1 << (bit & 31);
 }
 
-int bv_get(BitVector *bv, int bit)
+int bv_get(BitVector * bv, int bit)
 {
-  int byte = bit>>3;
-  if (byte >= bv->size) return 0;
-  return (bv->bits[byte]>>(bit&7))&1;
+    /* out of range so return 0 because it can't have been set */
+    if (bit >= bv->size) {
+        return bv->extends_as_ones;
+    }
+    return (bv->bits[bit >> 5] >> (bit & 31)) & 0x01;
 }
 
-void bv_clear(BitVector *bv)
+void bv_clear(BitVector * bv)
 {
-  memset(bv->bits, 0, bv->size);
-  bv->count = 0;
+    memset(bv->bits, 0, bv->capa * sizeof(f_u32));
+    bv->extends_as_ones = 0;
+    bv->count = 0;
+    bv->size = 0;
 }
 
-void bv_unset(BitVector *bv, int bit)
+/*
+ * FIXME: if the top set bit is unset, size is not adjusted. This will not
+ * cause any bugs in this code but could cause problems if users are relying
+ * on the fact that size is accurate.
+ */
+void bv_unset(BitVector * bv, int bit)
+{
+    f_u32 *word_p;
+    f_u32 bitmask;
+    int word = bit >> 5;
+
+    if (bit >= bv->size) {
+        bv->size = bit + 1; /* size is max range of bits set */
+        if (word >= bv->capa) {
+            int capa = bv->capa << 1;
+
+            while (capa <= word) {
+                capa <<= 1;
+            }
+            REALLOC_N(bv->bits, f_u32, capa);
+            memset(bv->bits + bv->capa, (bv->extends_as_ones ? 0xFF : 0),
+                   sizeof(f_u32) * (capa - bv->capa));
+            bv->capa = capa;
+        }
+    }
+    
+    word_p = &(bv->bits[word]);
+    bitmask = 1 << (bit & 31);
+    if ((bitmask & *word_p) > 0) {
+        bv->count--; /* update count */
+        *word_p &= ~bitmask;
+    }
+}
+
+/* Table of bits per char. This table is used by the bv_recount method to
+ * optimize the counting of bits */
+static const uchar BYTE_COUNTS[] = {
+    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+};
+
+int bv_recount(BitVector * bv)
 {
-  uchar *byte_p;
-  uchar bitmask;
-  int byte = bit>>3;
-  
-  if (byte >= bv->size) return;
-  
-  byte_p = &(bv->bits[byte]);
-  bitmask = 1<<(bit&7);
-  if ((bitmask & *byte_p) > 0) {
-    bv->count--;
-    *byte_p &= ~bitmask;
-  }
+    /* if the vector has been modified */
+    int i, c = 0;
+    uchar *bytes = (uchar *)bv->bits; /* count by character */
+    const int num_bytes = (((bv->size >> 5) + 1) << 2);
+    if (bv->extends_as_ones) {
+        for (i = 0; i < num_bytes; i++) {
+            c += BYTE_COUNTS[~(bytes[i]) & 0xFF];  /* sum bits per char */
+        }
+    }
+    else {
+        for (i = 0; i < num_bytes; i++) {
+            c += BYTE_COUNTS[bytes[i]];     /* sum bits per char */
+        }
+    }
+    bv->count = c;
+    return c;
 }
 
-void bv_write(BitVector *bv, Store *store, char *name)
+void bv_scan_reset(BitVector * bv)
 {
-  OutStream *os = store->create_output(store, name);
-  os_write_vint(os, bv->size);
-  os_write_bytes(os, bv->bits, bv->size);
-  os_close(os);
+    bv->curr_bit = -1;
 }
 
-const uchar BYTE_COUNTS[] = { // table of bits/char
-  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+/* Table showing the number of trailing 0s in a char. This is used to optimize
+ * the bv_scan_next method.  */
+const int NUM_TRAILING_ZEROS[] = {
+    8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
 };
 
-int bv_count(BitVector *bv) 
+/*
+ * This method is highly optimized, hence the loop unrolling
+ */
+static inline int bv_get_1_offset(f_u32 word)
+{
+    if (word & 0xff) {
+        return NUM_TRAILING_ZEROS[word & 0xff];
+    }
+    else {
+        word >>= 8;
+        if (word & 0xff) {
+            return NUM_TRAILING_ZEROS[word & 0xff] + 8;
+        }
+        else {
+            word >>= 8;
+            if (word & 0xff) {
+                return NUM_TRAILING_ZEROS[word & 0xff] + 16;
+            }
+            else {
+                word >>= 8;
+                return NUM_TRAILING_ZEROS[word & 0xff] + 24;
+            }
+        }
+    }
+}
+    /*
+     * second fastest;
+     *
+     *   while ((inc = NUM_TRAILING_ZEROS[word & 0xff]) == 8) {
+     *       word >>= 8;
+     *       bit_pos += 8;
+     *   }
+     *
+     * third fastest;
+     *
+     *   bit_pos += inc;
+     *   if ((word & 0xffff) == 0) {
+     *     bit_pos += 16;
+     *     word >>= 16;
+     *   }
+     *   if ((word & 0xff) == 0) {
+     *     bit_pos += 8;
+     *     word >>= 8;
+     *   }
+     *   bit_pos += NUM_TRAILING_ZEROS[word & 0xff];
+     */
+
+int bv_scan_next_from(BitVector * bv, register const int from)
+{
+    register const f_u32 *const bits = bv->bits;
+    register const int word_size = (bv->size >> 5) + 1;
+    register int word_pos = from >> 5;
+    register int bit_pos = (from & 31);
+    register f_u32 word = bits[word_pos] >> bit_pos;
+
+    if (from >= bv->size) {
+        return -1;
+    }
+    if (word == 0) {
+        bit_pos = 0;
+        do {
+            word_pos++;
+            if (word_pos >= word_size) {
+                return -1;
+            }
+        } while (bits[word_pos] == 0);
+        word = bits[word_pos];
+    }
+
+    /* check the word a byte at a time as the NUM_TRAILING_ZEROS table would
+     * be too large for 32-bit integer or even a 16-bit integer */
+    bit_pos += bv_get_1_offset(word);
+
+    return bv->curr_bit = ((word_pos << 5) + bit_pos);
+}
+
+int bv_scan_next(BitVector * bv)
+{
+    return bv_scan_next_from(bv, bv->curr_bit + 1);
+}
+
+int bv_scan_next_unset_from(BitVector * bv, register const int from)
+{
+    register const f_u32 *const bits = bv->bits;
+    register const int word_size = (bv->size >> 5) + 1;
+    register int word_pos = from >> 5;
+    register int bit_pos = (from & 31);
+    register f_u32 word = ~(~(bits[word_pos]) >> bit_pos);
+
+    if (from >= bv->size) {
+        return -1;
+    }
+    if (word == 0xFFFFFFFF) {
+        bit_pos = 0;
+        do {
+            word_pos++;
+            if (word_pos >= word_size) {
+                return -1;
+            }
+        } while (bits[word_pos] == 0xFFFFFFFF);
+        word = bits[word_pos];
+    }
+
+    bit_pos += bv_get_1_offset(~word);
+
+    return bv->curr_bit = ((word_pos << 5) + bit_pos);
+}
+
+int bv_scan_next_unset(BitVector * bv)
+{
+    return bv_scan_next_unset_from(bv, bv->curr_bit + 1);
+}
+
+int bv_eq(BitVector *bv1, BitVector *bv2)
+{
+    if (bv1 == bv2) {
+        return true;
+    }
+    else if (bv1->extends_as_ones != bv2->extends_as_ones) {
+        return false;
+    }
+    else {
+        f_u32 *bits = bv1->bits;
+        f_u32 *bits2 = bv2->bits;
+        int min_size = min2(bv1->size, bv2->size);
+        int word_size = (min_size >> 5) + 1;
+        int ext_word_size = 0;
+
+        int i;
+
+        for (i = 0; i < word_size; i++) {
+            if (bits[i] != bits2[i]) {
+                return false;
+            }
+        }
+        if (bv1->size > min_size) {
+            bits = bv1->bits;
+            ext_word_size = (bv1->size >> 5) + 1;
+        }
+        else if (bv2->size > min_size) {
+            bits = bv2->bits;
+            ext_word_size = (bv2->size >> 5) + 1;
+        }
+        if (ext_word_size) {
+            const f_u32 expected = (bv1->extends_as_ones ? 0xFFFFFFFF : 0);
+            for (i = word_size; i < ext_word_size; i++) {
+                if (bits[i] != expected) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+ulong bv_hash(BitVector *bv)
 {
-  // if the vector has been modified
-  int i, c = 0;
-  uchar *bytes = bv->bits;
-  for (i = 0; i < bv->size; i++)
-    c += BYTE_COUNTS[bytes[i]]; // sum bits per char
-  bv->count = c;
-  return c;
+    ulong hash = 0;
+    const f_u32 empty_word = bv->extends_as_ones ? 0xFFFFFFFF : 0;
+    int i;
+    for (i = (bv->size >> 5); i >= 0; i--) {
+        const f_u32 word = bv->bits[i];
+        if (word != empty_word) {
+            hash = (hash << 1) ^ word;
+        }
+    }
+    hash = (hash << 1) | bv->extends_as_ones;
+    return hash;
+}
+
+static BitVector *bv_and_i(BitVector *bv, BitVector *bv1, BitVector *bv2)
+{
+    int i;
+    int min_size = min2(bv1->size, bv2->size);
+    int word_size = (min_size >> 5) + 1;
+    int capa = 4;
+    while (capa < word_size) {
+        capa <<= 1;
+    }
+    REALLOC_N(bv->bits, f_u32, capa);
+    bv->capa = capa;
+    bv->size = min_size;
+
+    if (bv1->extends_as_ones && bv2->extends_as_ones) {
+        bv->extends_as_ones = true;
+    }
+    else {
+        bv->extends_as_ones = false;
+    }
+
+    memset(bv->bits + word_size, (bv->extends_as_ones ? 0xFF : 0),
+           sizeof(f_u32) * (capa - word_size)); 
+
+    for (i = 0; i < word_size; i++) {
+        bv->bits[i] = bv1->bits[i] & bv2->bits[i];
+    }
+    bv_recount(bv);
+    return bv;
+}
+
+BitVector *bv_and(BitVector *bv1, BitVector *bv2)
+{
+    return bv_and_i(bv_new(), bv1, bv2);
 }
 
-BitVector *bv_read(Store *store, char *name)
+BitVector *bv_and_x(BitVector *bv1, BitVector *bv2)
 {
-  BitVector *bv = ALLOC(BitVector);
-  InStream *is = store->open_input(store, name);
-  bv->capa = bv->size = (int)is_read_vint(is);
-  bv->bits = ALLOC_N(uchar, bv->capa);
-  is_read_bytes(is, bv->bits, 0, bv->size);
-  is_close(is);
-  bv_count(bv);
-  return bv;
+    return bv_and_i(bv1, bv1, bv2);
 }
 
-void bv_scan_reset(BitVector *bv)
+static inline void bv_recapa(BitVector *bv, int new_capa)
 {
-  bv->curr_bit = -1;
+    if (bv->capa < new_capa) {
+        REALLOC_N(bv->bits, f_u32, new_capa);
+        memset(bv->bits + bv->capa, (bv->extends_as_ones ? 0xFF : 0),
+               sizeof(f_u32) * (new_capa - bv->capa)); 
+        bv->capa = new_capa;
+    }
 }
 
-inline int bv_scan_next_from(BitVector *bv, register const int from)
+static BitVector *bv_or_i(BitVector *bv, BitVector *bv1, BitVector *bv2)
 {
-  register const uchar *const bits = bv->bits;
-  register const int size = bv->size;
-  register int byte_pos = (from) >> 3;
-  register int inc = ((from) & 7);
-  register int bit = 1 << inc;
-  register int mask = 0xff << inc;
-  register int byte;
+    int i;
+    int max_size = max2(bv1->size, bv2->size);
+    int word_size = (max_size >> 5) + 1;
+    int capa = 4;
+    while (capa < word_size) {
+        capa <<= 1;
+    }
+    REALLOC_N(bv->bits, f_u32, capa);
+    bv->capa = capa;
+    bv->size = max_size;
 
-  if (byte_pos >= size) return -1;
-  if ((bits[byte_pos]&mask) == 0) {
-    inc = 0;
-    bit = 1;
-    do {
-      byte_pos++;
-      if (byte_pos >= size) return -1;
-    } while (bits[byte_pos] == 0);
-  }
+    bv_recapa(bv1, capa);
+    bv_recapa(bv2, capa);
 
-  byte = bits[byte_pos];
-  while ((byte & bit) == 0) {
-    bit <<= 1;
-    inc++;
-  }
+    if (bv1->extends_as_ones || bv2->extends_as_ones) {
+        bv->extends_as_ones = true;
+    }
+    else {
+        bv->extends_as_ones = false;
+    }
+
+    memset(bv->bits + word_size, (bv->extends_as_ones ? 0xFF : 0),
+           sizeof(f_u32) * (capa - word_size)); 
 
-  return bv->curr_bit = ((byte_pos << 3) + inc);
+    for (i = 0; i < word_size; i++) {
+        bv->bits[i] = bv1->bits[i] | bv2->bits[i];
+    }
+    bv_recount(bv);
+    return bv;
 }
 
-inline int bv_scan_next(BitVector *bv)
+BitVector *bv_or(BitVector *bv1, BitVector *bv2)
 {
-  return bv_scan_next_from(bv, bv->curr_bit+1);
+    return bv_or_i(bv_new(), bv1, bv2);
 }
 
+BitVector *bv_or_x(BitVector *bv1, BitVector *bv2)
+{
+    return bv_or_i(bv1, bv1, bv2);
+}
+
+static BitVector *bv_xor_i(BitVector *bv, BitVector *bv1, BitVector *bv2)
+{
+    int i;
+    int max_size = max2(bv1->size, bv2->size);
+    int word_size = (max_size >> 5) + 1;
+    int capa = 4;
+    while (capa < word_size) {
+        capa <<= 1;
+    }
+    REALLOC_N(bv->bits, f_u32, capa);
+    bv->capa = capa;
+    bv->size = max_size;
+
+    bv_recapa(bv1, capa);
+    bv_recapa(bv2, capa);
+
+    if (bv1->extends_as_ones != bv2->extends_as_ones) {
+        bv->extends_as_ones = true;
+    }
+    else {
+        bv->extends_as_ones = false;
+    }
+
+    memset(bv->bits + word_size, (bv->extends_as_ones ? 0xFF : 0),
+           sizeof(f_u32) * (capa - word_size)); 
+
+    for (i = 0; i < word_size; i++) {
+        bv->bits[i] = bv1->bits[i] ^ bv2->bits[i];
+    }
+    bv_recount(bv);
+    return bv;
+}
+
+BitVector *bv_xor(BitVector *bv1, BitVector *bv2)
+{
+    return bv_xor_i(bv_new(), bv1, bv2);
+}
+
+BitVector *bv_xor_x(BitVector *bv1, BitVector *bv2)
+{
+    return bv_xor_i(bv1, bv1, bv2);
+}
+
+static BitVector *bv_not_i(BitVector *bv, BitVector *bv1)
+{
+    int i;
+    int word_size = (bv1->size >> 5) + 1;
+    int capa = 4;
+    while (capa < word_size) {
+        capa <<= 1;
+    }
+    REALLOC_N(bv->bits, f_u32, capa);
+    bv->capa = capa;
+    bv->size = bv1->size;
+    bv->extends_as_ones = 1 - bv1->extends_as_ones;
+    memset(bv->bits + word_size, (bv->extends_as_ones ? 0xFF : 0),
+           sizeof(f_u32) * (capa - word_size)); 
+
+    for (i = 0; i < word_size; i++) {
+        bv->bits[i] = ~(bv1->bits[i]);
+    }
+    bv_recount(bv);
+    return bv;
+}
+
+BitVector *bv_not(BitVector *bv1)
+{
+    return bv_not_i(bv_new(), bv1);
+}
+
+BitVector *bv_not_x(BitVector *bv1)
+{
+    return bv_not_i(bv1, bv1);
+}