CGAL 4.7 - STL Extensions for CGAL: Generic Algorithms

\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)

CGAL 4.7 - STL Extensions for CGAL

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
Functions
Generic Algorithms
STL Extensions for CGAL Reference

##

## Functions

template<class InputIterator , class Size , class OutputIterator >
OutputIterator | CGAL::copy_n (InputIterator first, Size n, OutputIterator result)
template<class ForwardIterator >
std::pair< ForwardIterator, ForwardIterator > | CGAL::min_max_element (ForwardIterator first, ForwardIterator last)
| Computes the minimal and the maximal element of a range. More...
template<class ForwardIterator , class CompareMin , class CompareMax >
std::pair< ForwardIterator, ForwardIterator > | CGAL::min_max_element (ForwardIterator first, ForwardIterator last, CompareMin comp_min, CompareMax comp_max)
| Computes the minimal and the maximal element of a range. More...
template<class BidirectionalIterator >
BidirectionalIterator | CGAL::predecessor (BidirectionalIterator it)
template<class ForwardIterator >
ForwardIterator | CGAL::successor (ForwardIterator it)
template<typename ForwardIterator >
Iterator | CGAL::cpp11::next (ForwardIterator it)
| The function returns the result of `operator++` on a `ForwardIterator`. More...
template<typename BidirectionalIterator >
Iterator | CGAL::cpp11::prev (BidirectionalIterator it)
| The function returns the result of `operator--` on a `BidirectionalIterator`. More...
template<class InputIterator , class Size , class OutputIterator >
OutputIterator | CGAL::cpp11::copy_n (InputIterator first, Size count, OutputIterator result)
| Copies `n` items from an input iterator to an output iterator. More...

## Function Documentation

template<class InputIterator , class Size , class OutputIterator >

OutputIterator CGAL::copy_n | ( | InputIterator | first,
|  | Size | n,
|  | OutputIterator | result
| ) |  |

Deprecated:
  This function is deprecated, CGAL::cpp11::copy_n should be used instead.

Copies the first `n` items from `first` to `result`.

Returns
  the value of `result` after inserting the `n` items.

Note
  The STL release June 13, 1997, from SGI contains an equivalent function, but it is not part of the ISO standard.

See Also
  `CGAL::Counting_iterator<Iterator, Value>`

copies

`#include <CGAL/algorithm.h>`

template<class InputIterator , class Size , class OutputIterator >

OutputIterator CGAL::cpp11::copy_n | ( | InputIterator | first,
|  | Size | count,
|  | OutputIterator | result
| ) |  |

Copies `n` items from an input iterator to an output iterator.

Its exact behaviour is defined in Paragraph 25.3.1 of the C++ standard draft N3242.

Note
  This provides an implementation of the standard function `copy_n` from the C++0x standard. If `copy_n` is available in the `std::` namespace a using declaration is used, otherwise an alternative implementation from CGAL is used.

`#include <CGAL/algorithm.h>`

template<class ForwardIterator >

std::pair<ForwardIterator, ForwardIterator > CGAL::min_max_element | ( | ForwardIterator | first,
|  | ForwardIterator | last
| ) |  |

Computes the minimal and the maximal element of a range.

It is modeled after the STL functions `std::min_element` and `std::max_element`. The advantage of `min_max_element` compared to calling both STL functions is that one only iterates once over the sequence. This is more efficient especially for large and/or complex sequences.

Example

The following example program computes the minimal and maximal element of the sequence `(3,\,6,\,5)`. Hence the output is `min = 3, max = 6`.

File STL_Extension/min_max_element_example.cpp

#include <CGAL/algorithm.h>
#include <vector>
#include <iostream>
using std::vector;
using std::pair;
using std::cout;
using std::endl;
using CGAL::min_max_element;
int main()
{
vector< int > v;
v.push_back(3);
v.push_back(6);
v.push_back(5);
typedef std::vector< int >::iterator iterator;
pair< iterator, iterator > p = min_max_element(v.begin(), v.end());
cout << "min = " << *p.first << ", max = " << *p.second << endl;
return 0;
}

Returns
  a pair of iterators where the first component refers to the minimal and the second component refers to the maximal element in the range [`first`, `last`). The ordering is defined by `operator<` on the value type of `ForwardIterator`.

`#include <CGAL/algorithm.h>`

Examples:
  STL_Extension/min_max_element_example.cpp.

template<class ForwardIterator , class CompareMin , class CompareMax >

std::pair< ForwardIterator, ForwardIterator > CGAL::min_max_element | ( | ForwardIterator | first,
|  | ForwardIterator | last,
|  | CompareMin | comp_min,
|  | CompareMax | comp_max
| ) |  |

Computes the minimal and the maximal element of a range.

It is modeled after the STL functions `std::min_element` and `std::max_element`. The advantage of `min_max_element` compared to calling both STL functions is that one only iterates once over the sequence. This is more efficient especially for large and/or complex sequences.

Returns
  a pair of iterators where the first component refers to the minimal and the second component refers to the maximal element in the range [`first`, `last`).

Requires:
  `CompareMin` and `CompareMax` are adaptable binary function objects: `VT` \( \times\) `VT` \( \rightarrow\) `bool` where `VT` is the value type of `ForwardIterator`.

`#include <CGAL/algorithm.h>`

template<typename ForwardIterator >

Iterator CGAL::cpp11::next | ( | ForwardIterator | it) |  |

The function returns the result of `operator++` on a `ForwardIterator`.

The exact behaviour is described in Paragraph 24.4.4 of the C++ standard draft N3242.

Note
  There is actually no function in namespace `CGAL::cpp11` with this name, but a using declaration which imports a function from another namespace. By order of priority: the one in namespace `std` is used (provided by C++0x), if not found, then the one in namespace `boost` is used.

See Also
  boost::next
  `CGAL::cpp11::prev()`

`#include <CGAL/algorithm.h>`

template<class BidirectionalIterator >

BidirectionalIterator CGAL::predecessor | ( | BidirectionalIterator | it) |  |

Deprecated:
  This function is deprecated. `CGAL::cpp11::prev` should be used instead.

Returns the previous iterator, i.e. the result of `operator--` on a bidirectional iterator.

See Also
  `CGAL::successor()`

Returns
  `--it`.

`#include <CGAL/algorithm.h>`

template<typename BidirectionalIterator >

Iterator CGAL::cpp11::prev | ( | BidirectionalIterator | it) |  |

The function returns the result of `operator--` on a `BidirectionalIterator`.

The exact behaviour is described in Paragraph 24.4.4 of the C++ standard draft N3242.

Note
  If C++0x is available the function `std::prev` is imported into the namespace `CGAL::cpp11`, otherwise `CGAL::cpp11::prev` is declared with the signature as given in Paragraph 24.4.4 of the ISO C++ Standard and forwarded to `boost::prior`.

`#include <CGAL/algorithm.h>`

template<class ForwardIterator >

ForwardIterator CGAL::successor | ( | ForwardIterator | it) |  |

Deprecated:
  This function is deprecated. `CGAL::cpp11::next` should be used instead.

Returns the next iterator, i.e. the result of `operator++` on a forward iterator.

See Also
  `CGAL::predecessor()`

Returns
  `++it`.

`#include <CGAL/algorithm.h>`