Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r73249 - in sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html: . reference style tut
From: cpp.cabrera_at_[hidden]
Date: 2011-07-20 04:57:07

Next message: cpp.cabrera_at_[hidden]: "[Boost-commit] svn:boost r73250 - in sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html: . reference reference/hash"
Previous message: dsaritz_at_[hidden]: "[Boost-commit] svn:boost r73248 - sandbox/mmap/boost/mmap"

Author: alejandro
Date: 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
New Revision: 73249
URL: http://svn.boost.org/trac/boost/changeset/73249

Log:
Fixed typos in design and tut/false_positive. Added "complexity" class to CSS. Modified presentation colors for c_id and c_keyword in CSS. Updated reference/bloom to include complexity and use new class name. Fixed error in code in tut/quick.
Text files modified:
   sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/design.html | 2
   sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/reference/bloom.html | 128 ++++++++++++++++++++++++++-------------
   sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/style/my.css | 23 ++++++
   sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/false_positive.html | 2
   sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/quick.html | 2
   5 files changed, 109 insertions(+), 48 deletions(-)

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/design.html
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/design.html (original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/design.html 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
@@ -75,7 +75,7 @@
     <a name="default_hash"></a>
     <h4>Default Hash Functions</h4>
     <p>
- To make the Bloom filter easy to use, the HashFunctions template partameter has a default value. This way, if the user wishes to use a Bloom filter for a quick, non-critical task, the user has the ability to just declare and use.
+ To make the Bloom filter easy to use, the HashFunctions template parameter has a default value. This way, if the user wishes to use a Bloom filter for a quick, non-critical task, the user has the ability to just declare and use.
     </p>
     <p>
       The default hash function set consists of three boost_hash function objects. These are implemented by computing Boost.Functional hash_value and incrementing the result by the seed. The boost_hash function object is made available in the file boost/bloom_filter/hash/default.hpp for users that wish to use more or fewer hash functions to use their Bloom filter without having to create their own hash function object.

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/reference/bloom.html
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/reference/bloom.html (original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/reference/bloom.html 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
@@ -44,15 +44,15 @@
       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>,
                 <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code> = <code class="c_namespace">mpl::</code><code class="c_type">vector</code><<code class="c_type">boost_hash</code><<code class="c_type">T</code>, 3> > >
- <code class="c_keyword">class</code> <code class="c_id">bloom_filter</code> {
+ <code class="c_keyword">class</code> <code class="c_type">basic_bloom_filter</code> {
         <code class="c_comment">// exported typedefs</code>
         <code class="c_keyword">typedef</code> <code class="c_type">T value_type</code>;
         <code class="c_keyword">typedef</code> <code class="c_type">T key_type</code>;
         <code class="c_keyword">typedef</code> <code class="c_type">HashFunctions hash_function_type</code>;

         <code class="c_comment">// constructors</code>
- <code class="c_func">bloom_filter</code>();
- <code class="c_func">bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_namespace">std::initializer_list</code><<code class="c_type">T</code>>&); <code class="c_comment">// requires C++11</code>
+ <code class="c_func">basic_bloom_filter</code>();
+ <code class="c_func">basic_bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_namespace">std::initializer_list</code><<code class="c_type">T</code>>&); <code class="c_comment">// requires C++11</code>

         <<code class="c_keyword">typename</code> <code class="c_type">InputIterator</code>>
         <code class="c_func">basic_bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">start</code>, <code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">end</code>);
@@ -74,44 +74,44 @@

         <code class="c_comment">// auxilliary ops</code>
         <code class="c_type">void</code> <code class="c_func">clear</code>();
- <code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">bloom_filter</code>&);
+ <code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">basic_bloom_filter</code>&);

         <code class="c_comment">// union assign/intersect assign</code>
- <code class="c_type">bloom_filter</code>& <code class="c_func">operator|=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code>&);
- <code class="c_type">bloom_filter</code>& <code class="c_func">operator&=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code>&);
+ <code class="c_type">basic_bloom_filter</code>& <code class="c_func">operator|=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code>&);
+ <code class="c_type">basic_bloom_filter</code>& <code class="c_func">operator&=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code>&);
       };

       <code class="c_comment">// union</code>
       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>, <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code>>
- <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>
- <code class="c_func">operator|</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
- <code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
+ <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>
+ <code class="c_func">operator|</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
+ <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);

       <code class="c_comment">// intersect</code>
       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>, <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code>>
- <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>
- <code class="c_func">operator&</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
- <code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
+ <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>
+ <code class="c_func">operator&</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
+ <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);

       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>, <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code>>
- <code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
- <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
+ <code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
+ <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);

       <code class="c_comment">// equality</code>
       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>, <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code>>
       <code class="c_type">bool</code>
- <code class="c_func">operator==</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
- <code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
+ <code class="c_func">operator==</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
+ <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);

       <code class="c_keyword">template</code> <<code class="c_keyword">typename</code> <code class="c_type">T</code>, <code class="c_type">size_t</code> <code class="c_type">Size</code>,
                 <code class="c_keyword">class</code> <code class="c_type">HashFunctions</code>>
       <code class="c_type">bool</code>
- <code class="c_func">operator!=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
- <code class="c_keyword">const</code> <code class="c_type">bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
+ <code class="c_func">operator!=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">lhs</code>,
+ <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter</code><<code class="c_type">T, Size, HashFunctions</code>>& <code class="c_id">rhs</code>);
     </div>
     <p>
       The basic Bloom filter data structure. Supports insertion and query. Allows setting of bit capacity, type, and hash functions at compile-time. This structure is best used when:
@@ -123,21 +123,23 @@
     </ul>

     <h2>Template Parameters Reference</h2>
- <dl>
- <dt>T</dt>
- <dd>The type used for all Bloom filter operations.</dd>
- <dt>Size</dt>
- <dd>The size in bits of the underlying std::bitset used by the Bloom filter.</dd>
- <dt>HashFunctions</dt>
- <dd>The set of hash functions used by the Bloom filter. Currently required to be an mpl::vector of Hashers.</dd>
- </dl>
+ <div class="template_ref">
+ <dl>
+ <dt>T</dt>
+ <dd>The type used for all Bloom filter operations.</dd>
+ <dt>Size</dt>
+ <dd>The size in bits of the underlying std::bitset used by the Bloom filter.</dd>
+ <dt>HashFunctions</dt>
+ <dd>The set of hash functions used by the Bloom filter. Currently required to be an mpl::vector of Hashers.</dd>
+ </dl>
+ </div>

     <div class="toc">
       <p>Function Reference</p>
       <ul>
- <li>bloom_filter()</li>
- <li>bloom_filter(start, end)</li>
- <li>bloom_filter(initializer_list)</li>
+ <li>basic_bloom_filter()</li>
+ <li>basic_bloom_filter(start, end)</li>
+ <li>basic_bloom_filter(initializer_list)</li>
         <li>bit_capacity()</li>
         <li>num_hash_functions()</li>
         <li>false_positive_rate()</li>
@@ -162,30 +164,36 @@

     <div class="func_ref">
       <a name="default_constructor"></a>
- <div class="ref_listing"><code class="c_func">bloom_filter</code>();</div>
+ <div class="ref_listing"><code class="c_func">basic_bloom_filter</code>();</div>
       <dl>
         <dt>Description</dt>
- <dd>Constructs a bloom_filter object with all bits set to 0.</dd>
+ <dd>Constructs a basic_bloom_filter object with all bits set to 0.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="range_constructor"></a>
- <div class="ref_listing"><code class="c_func">bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">start</code>, <code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">end</code>);</div>
+ <div class="ref_listing"><code class="c_func">basic_bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">start</code>, <code class="c_keyword">const</code> <code class="c_type">InputIterator</code> <code class="c_id">end</code>);</div>
       <dl>
         <dt>Description</dt>
- <dd>Constructs a bloom_filter by inserting all the elements in the range (start, end).</dd>
+ <dd>Constructs a basic_bloom_filter by inserting all the elements in the range (start, end).</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(n)</span>, such that n=distance(start, end).</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="ilist_constructor"></a>
- <div class="ref_listing"><code class="c_func">bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_namespace">std::initializer</code><<code class="c_type">T</code>>&);</div>
+ <div class="ref_listing"><code class="c_func">basic_bloom_filter</code>(<code class="c_keyword">const</code> <code class="c_namespace">std::initializer</code><<code class="c_type">T</code>>&);</div>
       <dl>
         <dt>Description</dt>
- <dd>Constructs a bloom_filter by inserting all elements in the initializer list.</dd>
+ <dd>Constructs a basic_bloom_filter by inserting all elements in the initializer list.</dd>
         <dt>Warning</dt>
         <dd>Only available in C++11-supporting compilers.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(n)</span>, such that n=size(init_list).</dd>
       </dl>
     </div>

@@ -197,6 +205,8 @@
         <dd>Returns the number of bits used internally by the Bloom filter..</dd>
         <dt>Returns</dt>
         <dd>Value of template parameter Size.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

@@ -209,6 +219,8 @@
         <dd>Returns the number of hash functions used by the Bloom filter.</dd>
         <dt>Returns</dt>
         <dd>mpl::size<HashFunctions>.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

@@ -220,6 +232,8 @@
         <dd>Returns the current false positive rate based upon the number of hash functions used (k), the number of bits available (m), and the number of bits set (n).</dd>
         <dt>Returns</dt>
         <dd>A double precision value calculated as (1 - e^(k*n/m))^k.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

@@ -231,6 +245,8 @@
         <dd>Returns true if no elements have been inserted into the Bloom filter.</dd>
         <dt>Returns</dt>
         <dd>std::bitset.count() == 0</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.count().</dd>
       </dl>
     </div>

@@ -242,6 +258,8 @@
         <dd>Returns the number of bits currently set in the Bloom filter.</dd>
         <dt>Returns</dt>
         <dd>std::bitset.count().</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.count().</dd>
       </dl>
     </div>

@@ -253,6 +271,8 @@
         <dd>Inserts an element into the Bloom filter.</dd>
         <dt>Post-condition</dt>
         <dd>At least 1 bit and at most num_hash_functions() bits of the Bloom filter will have been set.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(k)</span>, such that k=num_hash_functions()</dd>
       </dl>
     </div>

@@ -264,6 +284,8 @@
         <dd>Inserts all elements in range (start, end).</dd>
         <dt>Post-condition</dt>
         <dd>At least n bits and at most (n * num_hash_functions()) bits of the Bloom filter will have been set, where n = distance(start, end).</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(n*k)</span>, as above.</dd>
       </dl>
     </div>

@@ -277,6 +299,8 @@
         <dd>True if all hash functions agree with the bitset; false otherwise.</dd>
         <dt>Warning</dt>
         <dd>It may return a false positive if there are hash collisions - this means that depending on the Size of the Bloom filter and the hash functions used, there is a probability that the Bloom filter will return true even though the element was never inserted.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(k)</span>.</dd>
       </dl>
     </div>

@@ -288,21 +312,25 @@
         <dd>Sets all bits in the Bloom filter to 0, effectively canceling all insertions.</dd>
         <dt>Post-condition</dt>
         <dd>this->count() == 0</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.clear().</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="swap"></a>
- <div class="ref_listing"><code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">bloom_filter</code>&);</div>
+ <div class="ref_listing"><code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">basic_bloom_filter</code>&);</div>
       <dl>
         <dt>Description</dt>
         <dd>Swaps the bits in this Bloom filter with the argument Bloom filter.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="union_assign"></a>
- <div class="ref_listing"><code class="c_type">bloom_filter&</code> <code class="c_func">operator|=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code>);</div>
+ <div class="ref_listing"><code class="c_type">basic_bloom_filter&</code> <code class="c_func">operator|=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Performs a union.</dd>
@@ -310,12 +338,14 @@
         <dd>Returns a reference to <code class="c_keyword">this</code>.</dd>
         <dt>Post-condition</dt>
         <dd>The number of bits set in <code class="c_keyword">this</code> will be greater than or equal to the number of bits set before the operation.</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator|=</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="intersect_assign"></a>
- <div class="ref_listing"><code class="c_type">bloom_filter&</code> <code class="c_func">operator&=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code>);</div>
+ <div class="ref_listing"><code class="c_type">basic_bloom_filter&</code> <code class="c_func">operator&=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Performs an intersection.</dd>
@@ -323,12 +353,14 @@
         <dd>Returns a reference to <code class="c_keyword">this</code>.</dd>
         <dt>Post-condition</dt>
         <dd>The number of bits set in <code class="c_keyword">this</code> will be less than or equal to the number of bits set before the operation.</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator&=</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="union"></a>
- <div class="ref_listing"><code class="c_type">bloom_filter&</code> <code class="c_func">operator|</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">rhs</code>);</div>
+ <div class="ref_listing"><code class="c_type">basic_bloom_filter&</code> <code class="c_func">operator|</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">rhs</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Performs a union.</dd>
@@ -336,12 +368,14 @@
         <dd>Returns a new, stack-allocated Bloom filter that is the result of performing a union between the lhs and the rhs.</dd>
         <dt>Post-condition</dt>
         <dd>The number of bits set in the new filter will be greater than or equal to the number of bits set in max(lhs.count(), rhs.count()).</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator|</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="intersect"></a>
- <div class="ref_listing"><code class="c_type">bloom_filter&</code> <code class="c_func">operator&</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">rhs</code>);</div>
+ <div class="ref_listing"><code class="c_type">basic_bloom_filter&</code> <code class="c_func">operator&</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">rhs</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Performs an intersection.</dd>
@@ -349,37 +383,45 @@
         <dd>Returns a new, stack-allocated Bloom filter that is the result of performing an intersect between the lhs and the rhs.</dd>
         <dt>Post-condition</dt>
         <dd>The number of bits set in the new filter will be less than or equal to the number of bits set in min(lhs.count(), rhs.count()).</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator&</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="global_swap"></a>
- <div class="ref_listing"><code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">bloom_filter</code>&, <code class="c_type">bloom_filter</code>&);</div>
+ <div class="ref_listing"><code class="c_type">void</code> <code class="c_func">swap</code>(<code class="c_type">basic_bloom_filter</code>&, <code class="c_type">basic_bloom_filter</code>&);</div>
       <dl>
         <dt>Description</dt>
         <dd>Swaps the bits between the argument Bloom filters.</dd>
+ <dt>Complexity</dt>
+ <dd><span class="complexity">O(1)</span>.</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="operator_equality"></a>
- <div class="ref_listing"><code class="c_type">bool</code> <code class="c_func">operator==</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">rhs</code>);</div>
+ <div class="ref_listing"><code class="c_type">bool</code> <code class="c_func">operator==</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">rhs</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Compares the bits of the argument Bloom filters for equality.</dd>
         <dt>Returns</dt>
         <dd>True if the bits match, false otherwise.</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator==</dd>
       </dl>
     </div>

     <div class="func_ref">
       <a name="operator_inequality"></a>
- <div class="ref_listing"><code class="c_type">bool</code> <code class="c_func">operator!=</code>(<code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">bloom_filter&</code> <code class="c_id">rhs</code>);</div>
+ <div class="ref_listing"><code class="c_type">bool</code> <code class="c_func">operator!=</code>(<code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">lhs</code>, <code class="c_keyword">const</code> <code class="c_type">basic_bloom_filter&</code> <code class="c_id">rhs</code>);</div>
       <dl>
         <dt>Description</dt>
         <dd>Compares the bits of the argument Bloom filters for equality.</dd>
         <dt>Returns</dt>
         <dd>True if the bits don't match, false otherwise.</dd>
+ <dt>Complexity</dt>
+ <dd>Dependent on the implementation of std::bitset.operator!=</dd>
       </dl>
     </div>
     <hr/>

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/style/my.css
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/style/my.css (original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/style/my.css 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
@@ -28,6 +28,10 @@
     margin: 1% 2%;
}

+.complexity {
+ font-family: "Unicode Symbols";
+}
+
.header {
     height: 94px;
     position: relative;
@@ -76,6 +80,21 @@
     margin: 0 5%;
}

+.template_ref {
+ display: block;
+ background: #e0e0e0;
+ border: 1px solid;
+ margin: 1% 1%;
+}
+
+.template_ref dl {
+ margin: 1% 1%;
+}
+
+.template_ref dl dt {
+ font-weight: bold;
+}
+
.func_ref {
     background-color: #f0f0f0;
     display: block;
@@ -119,7 +138,7 @@
}

.c_keyword {
- color: fuchsia;
+ color: #800080;
}

.c_namespace {
@@ -131,7 +150,7 @@
}

.c_id {
- color: red;
+ color: #ff7700;
}

.c_func {

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/false_positive.html
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/false_positive.html (original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/false_positive.html 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
@@ -52,7 +52,7 @@
     </div>

     <p>
- The forumla above provides a close approximation of the actual false postive
+ The formula above provides a close approximation of the actual false postive
       rate. In order to find the best combination of parameters for your application,
       it is always best to benchmark.
     </p>

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/quick.html
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/quick.html (original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html/tut/quick.html 2011-07-20 04:57:04 EDT (Wed, 20 Jul 2011)
@@ -65,7 +65,7 @@
         }

         <code class="c_keyword">for</code> (<code class="c_type">int</code><code class="c_id"> i</code> = INSERT_MAX; i < CONTAINS_MAX; ++i) {
- <code class="c_keyword">if</code> (bloom.probably_contains(i)) cout << "collision" << endl;
+ <code class="c_keyword">if</code> (bloom.probably_contains(i)) ++collisions;
         }

         cout << <code class="c_str">"collisions: "</code>

Next message: cpp.cabrera_at_[hidden]: "[Boost-commit] svn:boost r73250 - in sandbox/bloom_filter/trunk/libs/bloom_filter/doc/html: . reference reference/hash"
Previous message: dsaritz_at_[hidden]: "[Boost-commit] svn:boost r73248 - sandbox/mmap/boost/mmap"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk