From 733b5d5ae2c5d625211e2985ac25728ac3f54883 Mon Sep 17 00:00:00 2001 From: DongHun Kwak Date: Mon, 21 Mar 2016 15:45:20 +0900 Subject: Imported Upstream version 1.58.0 Change-Id: If0072143aa26874812e0db6872e1efb10a3e5e94 Signed-off-by: DongHun Kwak --- doc/html/boost/heap/MergablePriorityQueue.html | 22 +-- doc/html/boost/heap/MutablePriorityQueue.html | 22 +-- doc/html/boost/heap/PriorityQueue.html | 20 +-- doc/html/boost/heap/allocator.html | 8 +- doc/html/boost/heap/arity.html | 10 +- doc/html/boost/heap/binomial_heap.html | 162 +++++++++---------- doc/html/boost/heap/compare.html | 8 +- doc/html/boost/heap/constant_time_size.html | 10 +- doc/html/boost/heap/d_ary_heap.html | 166 +++++++++---------- doc/html/boost/heap/fibonacci_heap.html | 178 ++++++++++----------- doc/html/boost/heap/heap_merge.html | 8 +- doc/html/boost/heap/mutable_.html | 10 +- doc/html/boost/heap/pairing_heap.html | 168 +++++++++---------- doc/html/boost/heap/priority_queue.html | 118 +++++++------- doc/html/boost/heap/skew_heap.html | 162 +++++++++---------- .../heap/skew_heap/implementation_defined.html | 6 +- doc/html/boost/heap/stability_counter_type.html | 8 +- doc/html/boost/heap/stable.html | 10 +- doc/html/boost/heap/store_parent_pointer.html | 10 +- 19 files changed, 552 insertions(+), 554 deletions(-) (limited to 'doc/html/boost/heap') diff --git a/doc/html/boost/heap/MergablePriorityQueue.html b/doc/html/boost/heap/MergablePriorityQueue.html index 3ba7c86552..bb7e6927a6 100644 --- a/doc/html/boost/heap/MergablePriorityQueue.html +++ b/doc/html/boost/heap/MergablePriorityQueue.html @@ -6,7 +6,7 @@ - + @@ -20,7 +20,7 @@

@@ -41,18 +41,18 @@ typedef C::value_type value_type; typedef C::const_reference const_reference; - // public member functions - BOOST_CONCEPT_USAGE(MergablePriorityQueue); - BOOST_CONCEPT_USAGE(PriorityQueue); + // public member functions + BOOST_CONCEPT_USAGE(MergablePriorityQueue); + BOOST_CONCEPT_USAGE(PriorityQueue); };

Description

-`MergablePriorityQueue` public member functions

+`MergablePriorityQueue` public member functions

 BOOST_CONCEPT_USAGE(MergablePriorityQueue);

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

 BOOST_CONCEPT_USAGE(MergablePriorityQueue);

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

@@ -67,7 +67,7 @@

diff --git a/doc/html/boost/heap/MutablePriorityQueue.html b/doc/html/boost/heap/MutablePriorityQueue.html index a004f92c9e..c92ecd3608 100644 --- a/doc/html/boost/heap/MutablePriorityQueue.html +++ b/doc/html/boost/heap/MutablePriorityQueue.html @@ -7,7 +7,7 @@ - + @@ -20,7 +20,7 @@

@@ -42,9 +42,9 @@ typedef C::value_type value_type; typedef C::const_reference const_reference; - // public member functions - BOOST_CONCEPT_USAGE(MutablePriorityQueue); - BOOST_CONCEPT_USAGE(PriorityQueue); + // public member functions + BOOST_CONCEPT_USAGE(MutablePriorityQueue); + BOOST_CONCEPT_USAGE(PriorityQueue); // public data members C c; @@ -52,13 +52,13 @@ bool not_equal; };

Description

-`MutablePriorityQueue` public member functions

+`MutablePriorityQueue` public member functions

 BOOST_CONCEPT_USAGE(MutablePriorityQueue);

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

 BOOST_CONCEPT_USAGE(MutablePriorityQueue);

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

@@ -73,7 +73,7 @@

diff --git a/doc/html/boost/heap/PriorityQueue.html b/doc/html/boost/heap/PriorityQueue.html index 7527b223c8..100fa85e00 100644 --- a/doc/html/boost/heap/PriorityQueue.html +++ b/doc/html/boost/heap/PriorityQueue.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -41,15 +41,15 @@ typedef C::value_type value_type; typedef C::const_reference const_reference; - // public member functions - BOOST_CONCEPT_USAGE(PriorityQueue); + // public member functions + BOOST_CONCEPT_USAGE(PriorityQueue); };

Description

-`PriorityQueue` public member functions

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

+`PriorityQueue` public member functions

```
 BOOST_CONCEPT_USAGE(PriorityQueue);
```

@@ -63,7 +63,7 @@

diff --git a/doc/html/boost/heap/allocator.html b/doc/html/boost/heap/allocator.html index 15c86b4f18..f3a3692491 100644 --- a/doc/html/boost/heap/allocator.html +++ b/doc/html/boost/heap/allocator.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -45,7 +45,7 @@

diff --git a/doc/html/boost/heap/arity.html b/doc/html/boost/heap/arity.html index 12b5628d51..57fff3caad 100644 --- a/doc/html/boost/heap/arity.html +++ b/doc/html/boost/heap/arity.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -35,7 +35,7 @@ struct arity { };

Description

Specifies the arity of a D-ary heap

@@ -49,7 +49,7 @@

diff --git a/doc/html/boost/heap/binomial_heap.html b/doc/html/boost/heap/binomial_heap.html index bf71376674..1122790678 100644 --- a/doc/html/boost/heap/binomial_heap.html +++ b/doc/html/boost/heap/binomial_heap.html @@ -50,46 +50,46 @@ typedef implementation_defined::handle_type handle_type; // construct/copy/destruct - explicit binomial_heap(value_compare const & = value_compare()); - binomial_heap(binomial_heap const &); - binomial_heap(binomial_heap &&); - binomial_heap & operator=(binomial_heap const &); - binomial_heap & operator=(binomial_heap &&); - ~binomial_heap(void); + explicit binomial_heap(value_compare const & = value_compare()); + binomial_heap(binomial_heap const &); + binomial_heap(binomial_heap &&); + binomial_heap & operator=(binomial_heap const &); + binomial_heap & operator=(binomial_heap &&); + ~binomial_heap(void); - // public member functions - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - void swap(binomial_heap &); - const_reference top(void) const; - handle_type push(value_type const &); - template<class... Args> handle_type emplace(Args &&...); - void pop(void); - void update(handle_type, const_reference); - void update(handle_type); - void increase(handle_type, const_reference); - void increase(handle_type); - void decrease(handle_type, const_reference); - void decrease(handle_type); - void merge(binomial_heap &); - iterator begin(void) const; - iterator end(void) const; - ordered_iterator ordered_begin(void) const; - ordered_iterator ordered_end(void) const; - void erase(handle_type); - value_compare const & value_comp(void) const; - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; + // public member functions + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + void swap(binomial_heap &); + const_reference top(void) const; + handle_type push(value_type const &); + template<class... Args> handle_type emplace(Args &&...); + void pop(void); + void update(handle_type, const_reference); + void update(handle_type); + void increase(handle_type, const_reference); + void increase(handle_type); + void decrease(handle_type, const_reference); + void decrease(handle_type); + void merge(binomial_heap &); + iterator begin(void) const; + iterator end(void) const; + ordered_iterator ordered_begin(void) const; + ordered_iterator ordered_end(void) const; + void erase(handle_type); + value_compare const & value_comp(void) const; + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; - // public static functions - static handle_type s_handle_from_iterator(iterator const &); + // public static functions + static handle_type s_handle_from_iterator(iterator const &); // public data members static const bool constant_time_size; @@ -99,7 +99,7 @@ static const bool has_reserve; };

Description

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

+

`binomial_heap` public types

@@ -123,196 +123,196 @@

+

`binomial_heap` public construct/copy/destruct

explicit binomial_heap(value_compare const & cmp = value_compare());

explicit binomial_heap(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

binomial_heap(binomial_heap const & rhs);

binomial_heap(binomial_heap const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
binomial_heap(binomial_heap && rhs);
```
+
```
binomial_heap(binomial_heap && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

binomial_heap & operator=(binomial_heap const & rhs);

binomial_heap & operator=(binomial_heap const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

-
```
binomial_heap & operator=(binomial_heap && rhs);
```
+
```
binomial_heap & operator=(binomial_heap && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
```
~binomial_heap(void);
```
```
~binomial_heap(void);
```

-`binomial_heap` public member functions

+`binomial_heap` public member functions

-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

void swap(binomial_heap & rhs);

void swap(binomial_heap & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
const_reference top(void) const;
```
+
```
const_reference top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.
-
```
handle_type push(value_type const & v);
```
+
```
handle_type push(value_type const & v);
```
Effects: Adds a new element to the priority queue. Returns handle to element

Complexity: Logarithmic.
-
```
template<class... Args> handle_type emplace(Args &&... args);
```
+
```
template<class... Args> handle_type emplace(Args &&... args);
```
Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.

Complexity: Logarithmic.
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic.

void update(handle_type handle, const_reference v);

void update(handle_type handle, const_reference v);

Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

-
```
void update(handle_type handle);
```
+
```
void update(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void increase(handle_type handle, const_reference v);
```
+
```
void increase(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one
-
```
void increase(handle_type handle);
```
+
```
void increase(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void decrease(handle_type handle, const_reference v);
```
+
```
void decrease(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one
-
```
void decrease(handle_type handle);
```
+
```
void decrease(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void merge(binomial_heap & rhs);

void merge(binomial_heap & rhs);

Effects: Merge with priority queue rhs.

Complexity: Logarithmic.

-
```
iterator begin(void) const;
```
+
```
iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void) const;
```
+
```
iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
ordered_iterator ordered_begin(void) const;
```
+
```
ordered_iterator ordered_begin(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
ordered_iterator ordered_end(void) const;
```
+
```
ordered_iterator ordered_end(void) const;
```
Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
void erase(handle_type handle);
```
+
```
void erase(handle_type handle);
```
Effects: Removes the element handled by handle from the priority_queue.

Complexity: Logarithmic.

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.

-`binomial_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

+`binomial_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

diff --git a/doc/html/boost/heap/compare.html b/doc/html/boost/heap/compare.html index 6d71efcc6f..d4db960aac 100644 --- a/doc/html/boost/heap/compare.html +++ b/doc/html/boost/heap/compare.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -45,7 +45,7 @@

diff --git a/doc/html/boost/heap/constant_time_size.html b/doc/html/boost/heap/constant_time_size.html index da593f0290..278f65a1a5 100644 --- a/doc/html/boost/heap/constant_time_size.html +++ b/doc/html/boost/heap/constant_time_size.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -35,7 +35,7 @@ struct constant_time_size { };

Description

Specifies, whether size() should have linear or constant complexity.

@@ -49,7 +49,7 @@

diff --git a/doc/html/boost/heap/d_ary_heap.html b/doc/html/boost/heap/d_ary_heap.html index 3ca125bc8f..8cddd484ac 100644 --- a/doc/html/boost/heap/d_ary_heap.html +++ b/doc/html/boost/heap/d_ary_heap.html @@ -50,48 +50,48 @@ typedef implementation_defined::handle_type handle_type; // construct/copy/destruct - explicit d_ary_heap(value_compare const & = value_compare()); - d_ary_heap(d_ary_heap const &); - d_ary_heap(d_ary_heap &&); - d_ary_heap & operator=(d_ary_heap &&); - d_ary_heap & operator=(d_ary_heap const &); + explicit d_ary_heap(value_compare const & = value_compare()); + d_ary_heap(d_ary_heap const &); + d_ary_heap(d_ary_heap &&); + d_ary_heap & operator=(d_ary_heap &&); + d_ary_heap & operator=(d_ary_heap const &); - // public member functions - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - value_type const & top(void) const; - mpl::if_c< is_mutable, handle_type, void >::type push(value_type const &); + // public member functions + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + value_type const & top(void) const; + mpl::if_c< is_mutable, handle_type, void >::type push(value_type const &); template<class... Args> - mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&...); - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; - void update(handle_type, const_reference); - void update(handle_type); - void increase(handle_type, const_reference); - void increase(handle_type); - void decrease(handle_type, const_reference); - void decrease(handle_type); - void erase(handle_type); - void pop(void); - void swap(d_ary_heap &); - const_iterator begin(void) const; - iterator begin(void); - iterator end(void); - const_iterator end(void) const; - ordered_iterator ordered_begin(void) const; - ordered_iterator ordered_end(void) const; - void reserve(size_type); - value_compare const & value_comp(void) const; + mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&...); + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; + void update(handle_type, const_reference); + void update(handle_type); + void increase(handle_type, const_reference); + void increase(handle_type); + void decrease(handle_type, const_reference); + void decrease(handle_type); + void erase(handle_type); + void pop(void); + void swap(d_ary_heap &); + const_iterator begin(void) const; + iterator begin(void); + iterator end(void); + const_iterator end(void) const; + ordered_iterator ordered_begin(void) const; + ordered_iterator ordered_end(void) const; + void reserve(size_type); + value_compare const & value_comp(void) const; - // public static functions - static handle_type s_handle_from_iterator(iterator const &); + // public static functions + static handle_type s_handle_from_iterator(iterator const &); // public data members static const bool constant_time_size; @@ -101,7 +101,7 @@ static const bool is_stable; };

Description

This class implements an immutable priority queue. Internally, the d-ary heap is represented as dynamically sized array (std::vector), that directly stores the values.

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

@@ -116,7 +116,7 @@

+

`d_ary_heap` public types

@@ -127,215 +127,215 @@

+

`d_ary_heap` public construct/copy/destruct

explicit d_ary_heap(value_compare const & cmp = value_compare());

explicit d_ary_heap(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

d_ary_heap(d_ary_heap const & rhs);

d_ary_heap(d_ary_heap const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
d_ary_heap(d_ary_heap && rhs);
```
+
```
d_ary_heap(d_ary_heap && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
-
```
d_ary_heap & operator=(d_ary_heap && rhs);
```
+
```
d_ary_heap & operator=(d_ary_heap && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

d_ary_heap & operator=(d_ary_heap const & rhs);

d_ary_heap & operator=(d_ary_heap const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

-`d_ary_heap` public member functions

+`d_ary_heap` public member functions

-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

-
```
value_type const & top(void) const;
```
+
```
value_type const & top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

mpl::if_c< is_mutable, handle_type, void >::type push(value_type const & v);

mpl::if_c< is_mutable, handle_type, void >::type push(value_type const & v);

Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

```
template<class... Args> 
-  mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&... args);
```
+ mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&... args);
Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized). Linear (worst case).

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
void update(handle_type handle, const_reference v);
```
+
```
void update(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Requirement: data structure must be configured as mutable
-
```
void update(handle_type handle);
```
+
```
void update(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable
-
```
void increase(handle_type handle, const_reference v);
```
+
```
void increase(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one

Requirement: data structure must be configured as mutable
-
```
void increase(handle_type handle);
```
+
```
void increase(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable
-
```
void decrease(handle_type handle, const_reference v);
```
+
```
void decrease(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one

Requirement: data structure must be configured as mutable
-
```
void decrease(handle_type handle);
```
+
```
void decrease(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable
-
```
void erase(handle_type handle);
```
+
```
void erase(handle_type handle);
```
Effects: Removes the element handled by handle from the priority_queue.

Complexity: Logarithmic.

Requirement: data structure must be configured as mutable
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void swap(d_ary_heap & rhs);

void swap(d_ary_heap & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
const_iterator begin(void) const;
```
+
```
const_iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator begin(void);
```
+
```
iterator begin(void);
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void);
```
+
```
iterator end(void);
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
const_iterator end(void) const;
```
+
```
const_iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
ordered_iterator ordered_begin(void) const;
```
+
```
ordered_iterator ordered_begin(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
ordered_iterator ordered_end(void) const;
```
+
```
ordered_iterator ordered_end(void) const;
```
Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
void reserve(size_type element_count);
```
+
```
void reserve(size_type element_count);
```
Effects: Reserves memory for element_count elements

Complexity: Linear.

Node: Invalidates iterators

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

-`d_ary_heap` public static functions

+`d_ary_heap` public static functions

-
```
static handle_type s_handle_from_iterator(iterator const & it);
```
+
```
static handle_type s_handle_from_iterator(iterator const & it);
```
Effects: Casts an iterator to a node handle.

Complexity: Constant.

Requirement: data structure must be configured as mutable
diff --git a/doc/html/boost/heap/fibonacci_heap.html b/doc/html/boost/heap/fibonacci_heap.html index 6b968ea01a..8450f639bb 100644 --- a/doc/html/boost/heap/fibonacci_heap.html +++ b/doc/html/boost/heap/fibonacci_heap.html @@ -7,7 +7,7 @@ - + @@ -20,7 +20,7 @@

- +

@@ -50,49 +50,48 @@ typedef implementation_defined::handle_type handle_type; // construct/copy/destruct - explicit fibonacci_heap(value_compare const & = value_compare()); - fibonacci_heap(fibonacci_heap const &); - fibonacci_heap(fibonacci_heap &&); - fibonacci_heap(fibonacci_heap &); - fibonacci_heap & operator=(fibonacci_heap &&); - fibonacci_heap & operator=(fibonacci_heap const &); - ~fibonacci_heap(void); + explicit fibonacci_heap(value_compare const & = value_compare()); + fibonacci_heap(fibonacci_heap const &); + fibonacci_heap(fibonacci_heap &&); + fibonacci_heap & operator=(fibonacci_heap &&); + fibonacci_heap & operator=(fibonacci_heap const &); + ~fibonacci_heap(void); - // public member functions - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - void swap(fibonacci_heap &); - value_type const & top(void) const; - handle_type push(value_type const &); - template<class... Args> handle_type emplace(Args &&...); - void pop(void); - void update(handle_type, const_reference); - void update_lazy(handle_type, const_reference); - void update(handle_type); - void update_lazy(handle_type); - void increase(handle_type, const_reference); - void increase(handle_type); - void decrease(handle_type, const_reference); - void decrease(handle_type); - void erase(handle_type const &); - iterator begin(void) const; - iterator end(void) const; - ordered_iterator ordered_begin(void) const; - ordered_iterator ordered_end(void) const; - void merge(fibonacci_heap &); - value_compare const & value_comp(void) const; - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; + // public member functions + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + void swap(fibonacci_heap &); + value_type const & top(void) const; + handle_type push(value_type const &); + template<class... Args> handle_type emplace(Args &&...); + void pop(void); + void update(handle_type, const_reference); + void update_lazy(handle_type, const_reference); + void update(handle_type); + void update_lazy(handle_type); + void increase(handle_type, const_reference); + void increase(handle_type); + void decrease(handle_type, const_reference); + void decrease(handle_type); + void erase(handle_type const &); + iterator begin(void) const; + iterator end(void) const; + ordered_iterator ordered_begin(void) const; + ordered_iterator ordered_end(void) const; + void merge(fibonacci_heap &); + value_compare const & value_comp(void) const; + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; - // public static functions - static handle_type s_handle_from_iterator(iterator const &); + // public static functions + static handle_type s_handle_from_iterator(iterator const &); // public data members static const bool constant_time_size; @@ -102,7 +101,7 @@ static const bool has_reserve; };
-
Description
+
Description

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

+

`fibonacci_heap` public construct/copy/destruct

explicit fibonacci_heap(value_compare const & cmp = value_compare());

explicit fibonacci_heap(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

fibonacci_heap(fibonacci_heap const & rhs);

fibonacci_heap(fibonacci_heap const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
fibonacci_heap(fibonacci_heap && rhs);
```
+
```
fibonacci_heap(fibonacci_heap && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
```
fibonacci_heap(fibonacci_heap & rhs);
```
-
```
fibonacci_heap & operator=(fibonacci_heap && rhs);
```
+
```
fibonacci_heap & operator=(fibonacci_heap && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

fibonacci_heap & operator=(fibonacci_heap const & rhs);

fibonacci_heap & operator=(fibonacci_heap const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

```
~fibonacci_heap(void);
```
```
~fibonacci_heap(void);
```

-`fibonacci_heap` public member functions

+`fibonacci_heap` public member functions

-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

void swap(fibonacci_heap & rhs);

void swap(fibonacci_heap & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
value_type const & top(void) const;
```
+
```
value_type const & top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.
-
```
handle_type push(value_type const & v);
```
+
```
handle_type push(value_type const & v);
```
Effects: Adds a new element to the priority queue. Returns handle to element

Complexity: Constant.

Note: Does not invalidate iterators.
-
```
template<class... Args> handle_type emplace(Args &&... args);
```
+
```
template<class... Args> handle_type emplace(Args &&... args);
```
Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.

Complexity: Constant.

Note: Does not invalidate iterators.
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).
-
```
void update(handle_type handle, const_reference v);
```
+
```
void update(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise.
-
```
void update_lazy(handle_type handle, const_reference v);
```
+
```
void update_lazy(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise.

Rationale: The lazy update function is a modification of the traditional update, that just invalidates the iterator to the object referred to by the handle.
-
```
void update(handle_type handle);
```
+
```
void update(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void update_lazy(handle_type handle);
```
(handle_type handle)
Effects: Assigns v to the element handled by handle & updates the priority queue.
+
```
void update_lazy(handle_type handle);
```
(handle_type handle)
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise. (handle_type handle)

Rationale: The lazy update function is a modification of the traditional update, that just invalidates the iterator to the object referred to by the handle.
-
```
void increase(handle_type handle, const_reference v);
```
+
```
void increase(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Constant.

Note: The new value is expected to be greater than the current one
-
```
void increase(handle_type handle);
```
+
```
void increase(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Constant.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void decrease(handle_type handle, const_reference v);
```
+
```
void decrease(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one
-
```
void decrease(handle_type handle);
```
+
```
void decrease(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void erase(handle_type const & handle);
```
+
```
void erase(handle_type const & handle);
```
Effects: Removes the element handled by handle from the priority_queue.

Complexity: Logarithmic.
-
```
iterator begin(void) const;
```
+
```
iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void) const;
```
+
```
iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
ordered_iterator ordered_begin(void) const;
```
+
```
ordered_iterator ordered_begin(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
ordered_iterator ordered_end(void) const;
```
+
```
ordered_iterator ordered_end(void) const;
```
Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void merge(fibonacci_heap & rhs);

void merge(fibonacci_heap & rhs);

Effects: Merge with priority queue rhs.

Complexity: Constant.

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.

-`fibonacci_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

+`fibonacci_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

@@ -343,7 +341,7 @@

diff --git a/doc/html/boost/heap/heap_merge.html b/doc/html/boost/heap/heap_merge.html index e2fcbfffc3..ba6aa486b5 100644 --- a/doc/html/boost/heap/heap_merge.html +++ b/doc/html/boost/heap/heap_merge.html @@ -6,7 +6,7 @@ - + @@ -20,7 +20,7 @@

@@ -35,7 +35,7 @@ template<typename Heap1, typename Heap2> void heap_merge(Heap1 & lhs, Heap2 & rhs);

Description

merge rhs into lhs

Effect: lhs contains all elements that have been part of rhs, rhs is empty.

@@ -50,7 +50,7 @@

diff --git a/doc/html/boost/heap/mutable_.html b/doc/html/boost/heap/mutable_.html index 3a0f9f5602..0042b7ffe9 100644 --- a/doc/html/boost/heap/mutable_.html +++ b/doc/html/boost/heap/mutable_.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

@@ -35,7 +35,7 @@ struct mutable_ { };

Description

Certain heaps need to be configured specifically do be mutable.

@@ -49,7 +49,7 @@

diff --git a/doc/html/boost/heap/pairing_heap.html b/doc/html/boost/heap/pairing_heap.html index a76aca74a0..e16d4453a5 100644 --- a/doc/html/boost/heap/pairing_heap.html +++ b/doc/html/boost/heap/pairing_heap.html @@ -7,7 +7,7 @@ - + @@ -20,7 +20,7 @@

@@ -50,46 +50,46 @@ typedef implementation_defined::handle_type handle_type; // construct/copy/destruct - explicit pairing_heap(value_compare const & = value_compare()); - pairing_heap(pairing_heap const &); - pairing_heap(pairing_heap &&); - pairing_heap & operator=(pairing_heap &&); - pairing_heap & operator=(pairing_heap const &); - ~pairing_heap(void); + explicit pairing_heap(value_compare const & = value_compare()); + pairing_heap(pairing_heap const &); + pairing_heap(pairing_heap &&); + pairing_heap & operator=(pairing_heap &&); + pairing_heap & operator=(pairing_heap const &); + ~pairing_heap(void); - // public member functions - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - void swap(pairing_heap &); - const_reference top(void) const; - handle_type push(value_type const &); - template<class... Args> handle_type emplace(Args &&...); - void pop(void); - void update(handle_type, const_reference); - void update(handle_type); - void increase(handle_type, const_reference); - void increase(handle_type); - void decrease(handle_type, const_reference); - void decrease(handle_type); - void erase(handle_type); - iterator begin(void) const; - iterator end(void) const; - ordered_iterator ordered_begin(void) const; - ordered_iterator ordered_end(void) const; - void merge(pairing_heap &); - value_compare const & value_comp(void) const; - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; + // public member functions + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + void swap(pairing_heap &); + const_reference top(void) const; + handle_type push(value_type const &); + template<class... Args> handle_type emplace(Args &&...); + void pop(void); + void update(handle_type, const_reference); + void update(handle_type); + void increase(handle_type, const_reference); + void increase(handle_type); + void decrease(handle_type, const_reference); + void decrease(handle_type); + void erase(handle_type); + iterator begin(void) const; + iterator end(void) const; + ordered_iterator ordered_begin(void) const; + ordered_iterator ordered_end(void) const; + void merge(pairing_heap &); + value_compare const & value_comp(void) const; + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; - // public static functions - static handle_type s_handle_from_iterator(iterator const &); + // public static functions + static handle_type s_handle_from_iterator(iterator const &); // public data members static const bool constant_time_size; @@ -99,7 +99,7 @@ static const bool has_reserve; };

Description

Pairing heaps are self-adjusting binary heaps. Although design and implementation are rather simple, the complexity analysis is yet unsolved. For details, consult:

Pettie, Seth (2005), "Towards a final analysis of pairing heaps", Proc. 46th Annual IEEE Symposium on Foundations of Computer Science, pp. 174-183

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

@@ -114,7 +114,7 @@

+

`pairing_heap` public types

@@ -125,196 +125,196 @@

+

`pairing_heap` public construct/copy/destruct

explicit pairing_heap(value_compare const & cmp = value_compare());

explicit pairing_heap(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

pairing_heap(pairing_heap const & rhs);

pairing_heap(pairing_heap const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
pairing_heap(pairing_heap && rhs);
```
+
```
pairing_heap(pairing_heap && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
-
```
pairing_heap & operator=(pairing_heap && rhs);
```
+
```
pairing_heap & operator=(pairing_heap && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

pairing_heap & operator=(pairing_heap const & rhs);

pairing_heap & operator=(pairing_heap const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

```
~pairing_heap(void);
```
```
~pairing_heap(void);
```

-`pairing_heap` public member functions

+`pairing_heap` public member functions

-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

void swap(pairing_heap & rhs);

void swap(pairing_heap & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
const_reference top(void) const;
```
+
```
const_reference top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.
-
```
handle_type push(value_type const & v);
```
+
```
handle_type push(value_type const & v);
```
Effects: Adds a new element to the priority queue. Returns handle to element

Complexity: 2**2*log(log(N)) (amortized).
-
```
template<class... Args> handle_type emplace(Args &&... args);
```
+
```
template<class... Args> handle_type emplace(Args &&... args);
```
Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.

Complexity: 2**2*log(log(N)) (amortized).
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized).
-
```
void update(handle_type handle, const_reference v);
```
+
```
void update(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: 2**2*log(log(N)) (amortized).
-
```
void update(handle_type handle);
```
+
```
void update(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: 2**2*log(log(N)) (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void increase(handle_type handle, const_reference v);
```
+
```
void increase(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be greater than the current one
-
```
void increase(handle_type handle);
```
+
```
void increase(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: 2**2*log(log(N)) (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void decrease(handle_type handle, const_reference v);
```
+
```
void decrease(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be less than the current one
-
```
void decrease(handle_type handle);
```
+
```
void decrease(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void erase(handle_type handle);
```
+
```
void erase(handle_type handle);
```
Effects: Removes the element handled by handle from the priority_queue.

Complexity: 2**2*log(log(N)) (amortized).
-
```
iterator begin(void) const;
```
+
```
iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void) const;
```
+
```
iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
ordered_iterator ordered_begin(void) const;
```
+
```
ordered_iterator ordered_begin(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
ordered_iterator ordered_end(void) const;
```
+
```
ordered_iterator ordered_end(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
void merge(pairing_heap & rhs);
```
+
```
void merge(pairing_heap & rhs);
```
Effects: Merge all elements from rhs into this

Complexity: 2**2*log(log(N)) (amortized).

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.

-`pairing_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

+`pairing_heap` public static functions

static handle_type s_handle_from_iterator(iterator const & it);

@@ -328,7 +328,7 @@

diff --git a/doc/html/boost/heap/priority_queue.html b/doc/html/boost/heap/priority_queue.html index d9147a4ff3..b8cfbf26ea 100644 --- a/doc/html/boost/heap/priority_queue.html +++ b/doc/html/boost/heap/priority_queue.html @@ -6,7 +6,7 @@ - + @@ -20,7 +20,7 @@

@@ -48,33 +48,33 @@ typedef implementation_defined::const_iterator const_iterator; // construct/copy/destruct - explicit priority_queue(value_compare const & = value_compare()); - priority_queue(priority_queue const &); - priority_queue(priority_queue &&); - priority_queue & operator=(priority_queue &&); - priority_queue & operator=(priority_queue const &); + explicit priority_queue(value_compare const & = value_compare()); + priority_queue(priority_queue const &); + priority_queue(priority_queue &&); + priority_queue & operator=(priority_queue &&); + priority_queue & operator=(priority_queue const &); - // public member functions - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - const_reference top(void) const; - void push(value_type const &); - template<class... Args> void emplace(Args &&...); - void pop(void); - void swap(priority_queue &); - iterator begin(void) const; - iterator end(void) const; - void reserve(size_type); - value_compare const & value_comp(void) const; - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; + // public member functions + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + const_reference top(void) const; + void push(value_type const &); + template<class... Args> void emplace(Args &&...); + void pop(void); + void swap(priority_queue &); + iterator begin(void) const; + iterator end(void) const; + void reserve(size_type); + value_compare const & value_comp(void) const; + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; // public data members static const bool constant_time_size; @@ -84,7 +84,7 @@ static const bool has_reserve; };

Description

The priority_queue class is a wrapper for the stl heap functions.
The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

@@ -97,7 +97,7 @@

+

`priority_queue` public types

@@ -108,139 +108,139 @@

+

`priority_queue` public construct/copy/destruct

explicit priority_queue(value_compare const & cmp = value_compare());

explicit priority_queue(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

priority_queue(priority_queue const & rhs);

priority_queue(priority_queue const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
priority_queue(priority_queue && rhs);
```
+
```
priority_queue(priority_queue && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
-
```
priority_queue & operator=(priority_queue && rhs);
```
+
```
priority_queue & operator=(priority_queue && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

priority_queue & operator=(priority_queue const & rhs);

priority_queue & operator=(priority_queue const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

-`priority_queue` public member functions

+`priority_queue` public member functions

-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

-
```
const_reference top(void) const;
```
+
```
const_reference top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.
-
```
void push(value_type const & v);
```
+
```
void push(value_type const & v);
```
Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).
-
```
template<class... Args> void emplace(Args &&... args);
```
+
```
template<class... Args> void emplace(Args &&... args);
```
Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized). Linear (worst case).
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void swap(priority_queue & rhs);

void swap(priority_queue & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
iterator begin(void) const;
```
+
```
iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void) const;
```
+
```
iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
void reserve(size_type element_count);
```
+
```
void reserve(size_type element_count);
```
Effects: Reserves memory for element_count elements

Complexity: Linear.

Node: Invalidates iterators

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.

@@ -256,7 +256,7 @@

diff --git a/doc/html/boost/heap/skew_heap.html b/doc/html/boost/heap/skew_heap.html index efa33dbbd8..1834e682c7 100644 --- a/doc/html/boost/heap/skew_heap.html +++ b/doc/html/boost/heap/skew_heap.html @@ -70,47 +70,47 @@ }; // construct/copy/destruct - explicit skew_heap(value_compare const & = value_compare()); - skew_heap(skew_heap const &); - skew_heap(skew_heap &&); - skew_heap & operator=(skew_heap const &); - skew_heap & operator=(skew_heap &&); - ~skew_heap(void); + explicit skew_heap(value_compare const & = value_compare()); + skew_heap(skew_heap const &); + skew_heap(skew_heap &&); + skew_heap & operator=(skew_heap const &); + skew_heap & operator=(skew_heap &&); + ~skew_heap(void); - // public member functions - mpl::if_c< is_mutable, handle_type, void >::type push(value_type const &); + // public member functions + mpl::if_c< is_mutable, handle_type, void >::type push(value_type const &); template<typename... Args> - mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&...); - bool empty(void) const; - size_type size(void) const; - size_type max_size(void) const; - void clear(void); - allocator_type get_allocator(void) const; - void swap(skew_heap &); - const_reference top(void) const; - void pop(void); - iterator begin(void) const; - iterator end(void) const; - ordered_iterator ordered_begin(void) const; - ordered_iterator ordered_end(void) const; - void merge(skew_heap &); - value_compare const & value_comp(void) const; - template<typename HeapType> bool operator<(HeapType const &) const; - template<typename HeapType> bool operator>(HeapType const &) const; - template<typename HeapType> bool operator>=(HeapType const &) const; - template<typename HeapType> bool operator<=(HeapType const &) const; - template<typename HeapType> bool operator==(HeapType const &) const; - template<typename HeapType> bool operator!=(HeapType const &) const; - void erase(handle_type); - void update(handle_type, const_reference); - void update(handle_type); - void increase(handle_type, const_reference); - void increase(handle_type); - void decrease(handle_type, const_reference); - void decrease(handle_type); + mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&...); + bool empty(void) const; + size_type size(void) const; + size_type max_size(void) const; + void clear(void); + allocator_type get_allocator(void) const; + void swap(skew_heap &); + const_reference top(void) const; + void pop(void); + iterator begin(void) const; + iterator end(void) const; + ordered_iterator ordered_begin(void) const; + ordered_iterator ordered_end(void) const; + void merge(skew_heap &); + value_compare const & value_comp(void) const; + template<typename HeapType> bool operator<(HeapType const &) const; + template<typename HeapType> bool operator>(HeapType const &) const; + template<typename HeapType> bool operator>=(HeapType const &) const; + template<typename HeapType> bool operator<=(HeapType const &) const; + template<typename HeapType> bool operator==(HeapType const &) const; + template<typename HeapType> bool operator!=(HeapType const &) const; + void erase(handle_type); + void update(handle_type, const_reference); + void update(handle_type); + void increase(handle_type, const_reference); + void increase(handle_type); + void decrease(handle_type, const_reference); + void decrease(handle_type); - // public static functions - static handle_type s_handle_from_iterator(iterator const &); + // public static functions + static handle_type s_handle_from_iterator(iterator const &); // public data members static const bool constant_time_size; @@ -121,7 +121,7 @@ static const bool is_mutable; };

Description

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

+

`skew_heap` public types

@@ -147,187 +147,187 @@

+

`skew_heap` public construct/copy/destruct

explicit skew_heap(value_compare const & cmp = value_compare());

explicit skew_heap(value_compare const & cmp = value_compare());

Effects: constructs an empty priority queue.

Complexity: Constant.

skew_heap(skew_heap const & rhs);

skew_heap(skew_heap const & rhs);

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

-
```
skew_heap(skew_heap && rhs);
```
+
```
skew_heap(skew_heap && rhs);
```
Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

skew_heap & operator=(skew_heap const & rhs);

skew_heap & operator=(skew_heap const & rhs);

Effects: Assigns priority queue from rhs.

Complexity: Linear.

-
```
skew_heap & operator=(skew_heap && rhs);
```
+
```
skew_heap & operator=(skew_heap && rhs);
```
Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
```
~skew_heap(void);
```
```
~skew_heap(void);
```

-`skew_heap` public member functions

+`skew_heap` public member functions

mpl::if_c< is_mutable, handle_type, void >::type push(value_type const & v);

mpl::if_c< is_mutable, handle_type, void >::type push(value_type const & v);

Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized).

```
template<typename... Args> 
-  mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&... args);
```
+ mpl::if_c< is_mutable, handle_type, void >::type emplace(Args &&... args);
Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized).
-
```
bool empty(void) const;
```
+
```
bool empty(void) const;
```
Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.
-
```
size_type size(void) const;
```
+
```
size_type size(void) const;
```
Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.
-
```
size_type max_size(void) const;
```
+
```
size_type max_size(void) const;
```
Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.
-
```
void clear(void);
```
+
```
void clear(void);
```
Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type get_allocator(void) const;

allocator_type get_allocator(void) const;

Effects: Returns allocator.

Complexity: Constant.

void swap(skew_heap & rhs);

void swap(skew_heap & rhs);

Effects: Swaps two priority queues.

Complexity: Constant.

-
```
const_reference top(void) const;
```
+
```
const_reference top(void) const;
```
Effects: Returns a const_reference to the maximum element.

Complexity: Constant.
-
```
void pop(void);
```
+
```
void pop(void);
```
Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized).
-
```
iterator begin(void) const;
```
+
```
iterator begin(void) const;
```
Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.
-
```
iterator end(void) const;
```
+
```
iterator end(void) const;
```
Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.
-
```
ordered_iterator ordered_begin(void) const;
```
+
```
ordered_iterator ordered_begin(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
ordered_iterator ordered_end(void) const;
```
+
```
ordered_iterator ordered_end(void) const;
```
Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.
-
```
void merge(skew_heap & rhs);
```
+
```
void merge(skew_heap & rhs);
```
Effects: Merge all elements from rhs into this

Complexity: Logarithmic (amortized).

value_compare const & value_comp(void) const;

value_compare const & value_comp(void) const;

Effect: Returns the value_compare object used by the priority queue

template<typename HeapType> bool operator<(HeapType const & rhs) const;

template<typename HeapType> bool operator<(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>(HeapType const & rhs) const;

template<typename HeapType> bool operator>(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

template<typename HeapType> bool operator>=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

template<typename HeapType> bool operator<=(HeapType const & rhs) const;

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

-
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator==(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
+
```
template<typename HeapType> bool operator!=(HeapType const & rhs) const;
```
Equivalent comparison Returns: True, if both heap data structures are not equivalent.
Requirement: the value_compare object of both heaps must match.
-
```
void erase(handle_type object);
```
+
```
void erase(handle_type object);
```
Effects: Removes the element handled by handle from the priority_queue.

Complexity: Logarithmic (amortized).
-
```
void update(handle_type handle, const_reference v);
```
+
```
void update(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic (amortized).
-
```
void update(handle_type handle);
```
+
```
void update(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void increase(handle_type handle, const_reference v);
```
+
```
void increase(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be greater than the current one
-
```
void increase(handle_type handle);
```
+
```
void increase(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
-
```
void decrease(handle_type handle, const_reference v);
```
+
```
void decrease(handle_type handle, const_reference v);
```
Effects: Assigns v to the element handled by handle & updates the priority queue.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be less than the current one
-
```
void decrease(handle_type handle);
```
+
```
void decrease(handle_type handle);
```
Effects: Updates the heap after the element handled by handle has been changed.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!
@@ -335,10 +335,10 @@

-`skew_heap` public static functions

+`skew_heap` public static functions

-
```
static handle_type s_handle_from_iterator(iterator const & it);
```
+
```
static handle_type s_handle_from_iterator(iterator const & it);
```
Effects: Casts an iterator to a node handle.

Complexity: Constant.

Requirement: data structure must be configured as mutable
diff --git a/doc/html/boost/heap/skew_heap/implementation_defined.html b/doc/html/boost/heap/skew_heap/implementation_defined.html index a3512e1b34..b5de788606 100644 --- a/doc/html/boost/heap/skew_heap/implementation_defined.html +++ b/doc/html/boost/heap/skew_heap/implementation_defined.html @@ -5,7 +5,7 @@ - + @@ -20,7 +20,7 @@

- +

@@ -61,7 +61,7 @@

- +
diff --git a/doc/html/boost/heap/stability_counter_type.html b/doc/html/boost/heap/stability_counter_type.html index c52408083f..e642e55a76 100644 --- a/doc/html/boost/heap/stability_counter_type.html +++ b/doc/html/boost/heap/stability_counter_type.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

- +

@@ -45,7 +45,7 @@

- +
diff --git a/doc/html/boost/heap/stable.html b/doc/html/boost/heap/stable.html index fd506b47dc..16a5036171 100644 --- a/doc/html/boost/heap/stable.html +++ b/doc/html/boost/heap/stable.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

- +

@@ -35,7 +35,7 @@ struct stable { };

-
Description
+
Description

A priority queue is stable, if elements with the same priority are popped from the heap, in the same order as they are inserted.

@@ -49,7 +49,7 @@

- +
diff --git a/doc/html/boost/heap/store_parent_pointer.html b/doc/html/boost/heap/store_parent_pointer.html index 1777782981..32ff1189f6 100644 --- a/doc/html/boost/heap/store_parent_pointer.html +++ b/doc/html/boost/heap/store_parent_pointer.html @@ -6,8 +6,8 @@ - - + + @@ -20,7 +20,7 @@

- +

@@ -35,7 +35,7 @@ struct store_parent_pointer { };

-
Description
+
Description

Maintaining a parent pointer adds some maintenance and size overhead, but iterating a heap is more efficient.

@@ -49,7 +49,7 @@

- +
-- cgit v1.2.3

Description

Description

-MergablePriorityQueue public member functions

+MergablePriorityQueue public member functions

Description

Description

-MutablePriorityQueue public member functions

+MutablePriorityQueue public member functions

Description

Description

-PriorityQueue public member functions

+PriorityQueue public member functions

Description

Description

Description

Description

+

binomial_heap public types

+

binomial_heap public construct/copy/destruct

-binomial_heap public member functions

+binomial_heap public member functions

-binomial_heap public static functions

+binomial_heap public static functions

Description

Description

Description

Description

+

d_ary_heap public types

+

d_ary_heap public construct/copy/destruct

-d_ary_heap public member functions

+d_ary_heap public member functions

-d_ary_heap public static functions

+d_ary_heap public static functions

Description

Description

+

fibonacci_heap public types

+

fibonacci_heap public construct/copy/destruct

-fibonacci_heap public member functions

+fibonacci_heap public member functions

-fibonacci_heap public static functions

+fibonacci_heap public static functions

Description

Description

Description

Description

Description

Description

+

pairing_heap public types

+

pairing_heap public construct/copy/destruct

-pairing_heap public member functions

+pairing_heap public member functions

-pairing_heap public static functions

+pairing_heap public static functions

Description

Description

+

priority_queue public types

+

priority_queue public construct/copy/destruct

-priority_queue public member functions

+priority_queue public member functions

Description

Description

+

skew_heap public types

+

skew_heap public construct/copy/destruct

-skew_heap public member functions

+skew_heap public member functions

-skew_heap public static functions

+skew_heap public static functions

Description

Description

-`MergablePriorityQueue` public member functions

+`MergablePriorityQueue` public member functions

-`MutablePriorityQueue` public member functions

+`MutablePriorityQueue` public member functions

-`PriorityQueue` public member functions

+`PriorityQueue` public member functions

`binomial_heap` public types

`binomial_heap` public construct/copy/destruct

-`binomial_heap` public member functions

+`binomial_heap` public member functions

-`binomial_heap` public static functions

+`binomial_heap` public static functions

`d_ary_heap` public types

`d_ary_heap` public construct/copy/destruct

-`d_ary_heap` public member functions

+`d_ary_heap` public member functions

-`d_ary_heap` public static functions

+`d_ary_heap` public static functions

`fibonacci_heap` public types

`fibonacci_heap` public construct/copy/destruct

-`fibonacci_heap` public member functions

+`fibonacci_heap` public member functions

-`fibonacci_heap` public static functions

+`fibonacci_heap` public static functions

`pairing_heap` public types

`pairing_heap` public construct/copy/destruct

-`pairing_heap` public member functions

+`pairing_heap` public member functions

-`pairing_heap` public static functions

+`pairing_heap` public static functions

`priority_queue` public types

`priority_queue` public construct/copy/destruct

-`priority_queue` public member functions

+`priority_queue` public member functions

`skew_heap` public types

`skew_heap` public construct/copy/destruct

-`skew_heap` public member functions

+`skew_heap` public member functions

-`skew_heap` public static functions

+`skew_heap` public static functions