Fix mistakes (#41)

* Update primer.adoc

* Update tutorial.adoc

* Update filter.adoc

* Update implementation_notes.adoc

* Update tutorial.adoc

* Update tutorial.adoc

Author: ivanpanch

doc/bloom/implementation_notes.adoc

@@ -127,7 +127,7 @@ with https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-r
 
 === `fast_multiblock64`
 
-We only provide a SIMD implementation for AVX2 that relies in two
+We only provide a SIMD implementation for AVX2 that relies on two
 parallel `+++__+++m256i`+++s+++ for the generation of up
 to 8 64-bit values with shifted 1s. For Neon and SSE2, emulation
-through 4 128-bit registers proved slower than non-SIMD `multiblock<uint64_t, K>`.
+through 4 128-bit registers proved slower than non-SIMD `multiblock<uint64_t, K>`.

doc/bloom/primer.adoc

@@ -48,7 +48,7 @@ The implementation of a classical Bloom filter consists of an array of _m_ bits,
 Inserting an element _x_ reduces to selecting _k_ positions pseudorandomly (with the help
 of _k_ independent hash functions) and setting them to one.
 
-image::bloom_insertion.png[align=center, title="Insertion in a classical Bloom filter with _k_ = 6 different hash functions. Inserting _x_ reduces to setting to one the bits at positions 10, 14, 43, 58, 1, and 39 as indicated by _h_~1~(_x_), ... , _h_~6~(_x_)."]
+image::bloom_insertion.png[align=center, title="Insertion in a classical Bloom filter with _k_ = 6 different hash functions. Inserting _x_ reduces to setting to one the bits at positions 10, 14, 43, 58, 1, and 39 as indicated by _h_~1~(_x_), ..., _h_~6~(_x_)."]
 
 To check if an element _y_ is in the filter, we follow the same procedure and see if
 the selected bits are all set to one. In the example figure there are two unset bits, which
@@ -65,7 +65,7 @@ when the array is sparsely populated, a higher value of _k_ improves (decreases)
 as there are more chances that we hit a non-set bit; however, if _k_ is very high
 the array will have more and more bits set to one as new elements are inserted, which
 eventually will reach a point where we lose out to a filter with a lower _k_ and
-thus a smaller proportions of set bits. For given values of _n_ and _m_, the optimum _k_ is
+thus a smaller proportion of set bits. For given values of _n_ and _m_, the optimum _k_ is
 {small}stem:[\lfloor k_{\text{opt}}\rfloor]{small-end} or
 {small}stem:[\lceil k_{\text{opt}}\rceil]{small-end}, with
 
@@ -123,4 +123,4 @@ multiblock filters and then block filters. Execution speed will roughly go
 in the reverse order. When considering block/multiblock filters with
 multi-insertion, the number of available configurations grows quickly and
 you will need to do some experimenting to locate your preferred point in the
-(FPR, capacity, speed) tradeoff space.
+(FPR, capacity, speed) tradeoff space.

doc/bloom/reference/filter.adoc

@@ -297,7 +297,7 @@ Postconditions:;; `*this == x`.
 filter(filter&& x);
 ----
 
-Constructs a filter tranferring `x`++'++s internal array to `*this` and using
+Constructs a filter transferring `x`++'++s internal array to `*this` and using
 a hash function and allocator move-constructed from `x`++'++s hash function
 and allocator, respectively.
 
@@ -355,7 +355,7 @@ Postconditions:;; `*this == x`.
 filter(filter&& x, const allocator_type& al);
 ----
 
-Constructs a filter tranferring `x`++'++s internal array to `*this` if
+Constructs a filter transferring `x`++'++s internal array to `*this` if
 `al == x.get_allocator()`, or using a copy of the array otherwise.
 The hash function of the new filter is move-constructed from `x`++'++s
 hash function and the allocator is a copy of `al`.
@@ -738,4 +738,4 @@ void swap(filter<T, K, S, B, H, A>& x, filter<T, K, S, B, H, A>& y)
 
 Equivalent to `x.xref:filter_swap[swap](y)`.
 
-'''
+'''

doc/bloom/tutorial.adoc

@@ -81,7 +81,7 @@ an array of 2^`N`^ unsigned integrals (e.g. `uint64_t[8]`). In general,
 the wider `Block` is, the better (lower) the resulting FPR, but
 cache locality worsens and performance may suffer as a result.
 
-Note that the total number of of bits set/checked for a
+Note that the total number of bits set/checked for a
 `boost::bloom::filter<T, K, _subfilter_<..., K'>>` is `K * K'`. The
 default configuration `boost::bloom::filter<T, K>` = 
 `boost::bloom::filter<T, K, block<unsigned char, 1>>`, which corresponds to a
@@ -91,7 +91,7 @@ subarray is accessed for each bit set/checked. Consult the
 xref:benchmarks[benchmarks section] to see different tradeoffs between FPR and
 performance.
 
-Once a subfilter have been selected, the parameter `K'` can be tuned
+Once a subfilter has been selected, the parameter `K'` can be tuned
 to its optimum value (minimum FPR) if the number of elements that will be inserted is
 known in advance, as explained in a xref:configuration[dedicated section];
 otherwise, low values of `K'` will generally be faster and preferred to
@@ -254,7 +254,7 @@ f &= f3; // f and f3 must have exactly the same capacity
 
 For AND combination, be aware that the resulting FPR will be in general
 worse (higher) than if the filter had been constructed from scratch
-by inserting only the commom elements -- don't trust `fpr_for` in this
+by inserting only the common elements -- don't trust `fpr_for` in this
 case.
 
 == Direct Access to the Array
@@ -339,7 +339,7 @@ file):
 (gdb) add-auto-load-safe-path _<path-to-executable>_
 -----
 
-Alternatively to the use of the embedded pretty-printer, you can explicitly
+As an alternative to using the embedded pretty-printer, you can explicitly
 load the link:../../extra/boost_bloom_printers.py[`boost_bloom_printers.py`^]
 script: