Improve docs.

Author: RinChanNOWWW

README.md

@@ -829,7 +829,7 @@ bool *bool_array = malloc((range_end - range_start) * sizeof(bool));
 roaring_bitmap_range_bool_array(r1, range_start, range_end, bool_array);
 
 // The bool_array now contains true/false for elements at positions [range_start, range_end)
-// bool_array[i] is true if the (range_start+i)-th element exists in the bitmap
+// bool_array[i] is true if the (range_start+i) exists in the bitmap
 
 // you must free the memory:
 free(bool_array);

include/roaring/containers/bitset.h

@@ -397,15 +397,6 @@ int bitset_container_to_uint32_array(uint32_t *out,
                                      const bitset_container_t *bc,
                                      uint32_t base);
 
-/*
- * Write out the 16-bit integers contained in this container as a list of 8-bit
- * booleans using base as the starting value (it might be expected that base has
- * zeros in its 16 least significant bits). The function returns the number of
- * values written. The caller is responsible for allocating enough memory in
- * out. The out pointer should point to enough memory (the cardinality times 8
- * bits).
- */
-
 /*
  * Print this container using printf (useful for debugging).
  */

include/roaring/containers/containers.h

@@ -2478,15 +2478,19 @@ bool container_iterator_read_into_uint64(const container_t *c, uint8_t typecode,
                                          uint16_t *value_out);
 
 /**
- * Reads entries until the the first entry whose value is greater than or equal
- * to `*max_value` from the container, and sets corresponding positions in `buf`
- * to true. If `max_value` is null, then all entries are read.
- * The `buf` array is filled starting from index 0, which corresponds
- * to the current iterator position `it`. For subsequent iterator positions
- * `it_new`, set `buf[it_new->current_value - it->current_value]` to true.
+ * Reads entries until the the last entry whose value is strictly smaller than
+ * `*max_value` from the container (*max_value is excluded), and sets
+ * corresponding positions in `buf` to true. If `max_value` is null, then all
+ * entries are read.
+ *
+ * The `buf` array is filled starting from index 0, which corresponds to the
+ * initial iterator position `it`. For subsequent iterator positions `it_new`,
+ * set `buf[it_new->current_value - it->current_value]` to true.
+ *
  * Returns true and sets `value_out` if a value is present after reading the
  * entries.
- * The initial `it` should has value.
+ *
+ * The initial `it` should have a value.
  */
 bool container_iterator_read_into_bool(const container_t *c, uint8_t typecode,
                                        roaring_container_iterator_t *it,

include/roaring/roaring.h

@@ -567,9 +567,8 @@ bool roaring_bitmap_to_bitset(const roaring_bitmap_t *r, bitset_t *bitset);
  *
  *     ans = malloc((range_end - range_start) * sizeof(bool));
  *
- * For more control, see `roaring_uint32_iterator_skip` and
- * `roaring_uint32_iterator_read_to_bool`, which can be used to e.g. tell how
- * many values were actually read.
+ * For more control, see `roaring_uint32_iterator_move_equalorlarger` and
+ * `roaring_uint32_iterator_read_into_bool`.
  */
 void roaring_bitmap_range_bool_array(const roaring_bitmap_t *r,
                                      uint32_t range_start, uint32_t range_end,
@@ -1228,14 +1227,14 @@ uint32_t roaring_uint32_iterator_read(roaring_uint32_iterator_t *it,
                                       uint32_t *buf, uint32_t count);
 
 /**
- * Reads until the first value that is greater than or equal to ${max_value} and
+ * Reads until the last value that is strictly smaller than `max_value`  and
  * fill the bool array `buf`.
  *
  * This function satisfies semantics of iteration and can be used together with
  * other iterator functions.
- *  - buf[0] will be set to true.
- *  - let `it1` be the initial iterator, and for every iterated `it`,
- * buf[it1.current_value - it.current_value] will be set to true; other
+ *
+ * Let `it1` be the initial iterator and it has value, then for every iterated
+ * `it`, buf[it1.current_value - it.current_value] will be set to true; other
  * positions will remain to be false.
  *  - after function returns, iterator is positioned at the next element
  */