OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [algorithmfwd.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe 
// <algorithm> declarations  -*- C++ -*-
2 
 
3 
// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 
//
5 
// This file is part of the GNU ISO C++ Library.  This library is free
6 
// software; you can redistribute it and/or modify it under the
7 
// terms of the GNU General Public License as published by the
8 
// Free Software Foundation; either version 3, or (at your option)
9 
// any later version.
10 
 
11 
// This library is distributed in the hope that it will be useful,
12 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 
// GNU General Public License for more details.
15 
 
16 
// Under Section 7 of GPL version 3, you are granted additional
17 
// permissions described in the GCC Runtime Library Exception, version
18 
// 3.1, as published by the Free Software Foundation.
19 
 
20 
// You should have received a copy of the GNU General Public License and
21 
// a copy of the GCC Runtime Library Exception along with this program;
22 
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 
// <http://www.gnu.org/licenses/>.
24 
 
25 
/** @file bits/algorithmfwd.h
26 
 *  This is an internal header file, included by other library headers.
27 
 *  Do not attempt to use it directly. @headername{algorithm}
28 
 */
29 
 
30 
#ifndef _GLIBCXX_ALGORITHMFWD_H
31 
#define _GLIBCXX_ALGORITHMFWD_H 1
32 
 
33 
#pragma GCC system_header
34 
 
35 
#include <bits/c++config.h>
36 
#include <bits/stl_pair.h>
37 
#include <bits/stl_iterator_base_types.h>
38 
#if __cplusplus >= 201103L
39 
#include <initializer_list>
40 
#endif
41 
 
42 
namespace std _GLIBCXX_VISIBILITY(default)
43 
{
44 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
45 
 
46 
  /*
47 
    adjacent_find
48 
    all_of (C++0x)
49 
    any_of (C++0x)
50 
    binary_search
51 
    copy
52 
    copy_backward
53 
    copy_if (C++0x)
54 
    copy_n (C++0x)
55 
    count
56 
    count_if
57 
    equal
58 
    equal_range
59 
    fill
60 
    fill_n
61 
    find
62 
    find_end
63 
    find_first_of
64 
    find_if
65 
    find_if_not (C++0x)
66 
    for_each
67 
    generate
68 
    generate_n
69 
    includes
70 
    inplace_merge
71 
    is_heap (C++0x)
72 
    is_heap_until (C++0x)
73 
    is_partitioned (C++0x)
74 
    is_sorted (C++0x)
75 
    is_sorted_until (C++0x)
76 
    iter_swap
77 
    lexicographical_compare
78 
    lower_bound
79 
    make_heap
80 
    max
81 
    max_element
82 
    merge
83 
    min
84 
    min_element
85 
    minmax (C++0x)
86 
    minmax_element (C++0x)
87 
    mismatch
88 
    next_permutation
89 
    none_of (C++0x)
90 
    nth_element
91 
    partial_sort
92 
    partial_sort_copy
93 
    partition
94 
    partition_copy (C++0x)
95 
    partition_point (C++0x)
96 
    pop_heap
97 
    prev_permutation
98 
    push_heap
99 
    random_shuffle
100 
    remove
101 
    remove_copy
102 
    remove_copy_if
103 
    remove_if
104 
    replace
105 
    replace_copy
106 
    replace_copy_if
107 
    replace_if
108 
    reverse
109 
    reverse_copy
110 
    rotate
111 
    rotate_copy
112 
    search
113 
    search_n
114 
    set_difference
115 
    set_intersection
116 
    set_symmetric_difference
117 
    set_union
118 
    shuffle (C++0x)
119 
    sort
120 
    sort_heap
121 
    stable_partition
122 
    stable_sort
123 
    swap
124 
    swap_ranges
125 
    transform
126 
    unique
127 
    unique_copy
128 
    upper_bound
129 
  */
130 
 
131 
  /**
132 
   * @defgroup algorithms Algorithms
133 
   *
134 
   * Components for performing algorithmic operations. Includes
135 
   * non-modifying sequence, modifying (mutating) sequence, sorting,
136 
   * searching, merge, partition, heap, set, minima, maxima, and
137 
   * permutation operations.
138 
   */
139 
 
140 
  /**
141 
   * @defgroup mutating_algorithms Mutating
142 
   * @ingroup algorithms
143 
   */
144 
 
145 
  /**
146 
   * @defgroup non_mutating_algorithms Non-Mutating
147 
   * @ingroup algorithms
148 
   */
149 
 
150 
  /**
151 
   * @defgroup sorting_algorithms Sorting
152 
   * @ingroup algorithms
153 
   */
154 
 
155 
  /**
156 
   * @defgroup set_algorithms Set Operation
157 
   * @ingroup sorting_algorithms
158 
   *
159 
   * These algorithms are common set operations performed on sequences
160 
   * that are already sorted. The number of comparisons will be
161 
   * linear.
162 
   */
163 
 
164 
  /**
165 
   * @defgroup binary_search_algorithms Binary Search
166 
   * @ingroup sorting_algorithms
167 
   *
168 
   * These algorithms are variations of a classic binary search, and
169 
   * all assume that the sequence being searched is already sorted.
170 
   *
171 
   * The number of comparisons will be logarithmic (and as few as
172 
   * possible).  The number of steps through the sequence will be
173 
   * logarithmic for random-access iterators (e.g., pointers), and
174 
   * linear otherwise.
175 
   *
176 
   * The LWG has passed Defect Report 270, which notes: <em>The
177 
   * proposed resolution reinterprets binary search. Instead of
178 
   * thinking about searching for a value in a sorted range, we view
179 
   * that as an important special case of a more general algorithm:
180 
   * searching for the partition point in a partitioned range.  We
181 
   * also add a guarantee that the old wording did not: we ensure that
182 
   * the upper bound is no earlier than the lower bound, that the pair
183 
   * returned by equal_range is a valid range, and that the first part
184 
   * of that pair is the lower bound.</em>
185 
   *
186 
   * The actual effect of the first sentence is that a comparison
187 
   * functor passed by the user doesn't necessarily need to induce a
188 
   * strict weak ordering relation.  Rather, it partitions the range.
189 
   */
190 
 
191 
  // adjacent_find
192 
 
193 
#if __cplusplus >= 201103L
194 
  template<typename _IIter, typename _Predicate>
195 
    bool
196 
    all_of(_IIter, _IIter, _Predicate);
197 
 
198 
  template<typename _IIter, typename _Predicate>
199 
    bool
200 
    any_of(_IIter, _IIter, _Predicate);
201 
#endif
202 
 
203 
  template<typename _FIter, typename _Tp>
204 
    bool
205 
    binary_search(_FIter, _FIter, const _Tp&);
206 
 
207 
  template<typename _FIter, typename _Tp, typename _Compare>
208 
    bool
209 
    binary_search(_FIter, _FIter, const _Tp&, _Compare);
210 
 
211 
  template<typename _IIter, typename _OIter>
212 
    _OIter
213 
    copy(_IIter, _IIter, _OIter);
214 
 
215 
  template<typename _BIter1, typename _BIter2>
216 
    _BIter2
217 
    copy_backward(_BIter1, _BIter1, _BIter2);
218 
 
219 
#if __cplusplus >= 201103L
220 
  template<typename _IIter, typename _OIter, typename _Predicate>
221 
    _OIter
222 
    copy_if(_IIter, _IIter, _OIter, _Predicate);
223 
 
224 
  template<typename _IIter, typename _Size, typename _OIter>
225 
    _OIter
226 
    copy_n(_IIter, _Size, _OIter);
227 
#endif
228 
 
229 
  // count
230 
  // count_if
231 
 
232 
  template<typename _FIter, typename _Tp>
233 
    pair<_FIter, _FIter>
234 
    equal_range(_FIter, _FIter, const _Tp&);
235 
 
236 
  template<typename _FIter, typename _Tp, typename _Compare>
237 
    pair<_FIter, _FIter>
238 
    equal_range(_FIter, _FIter, const _Tp&, _Compare);
239 
 
240 
  template<typename _FIter, typename _Tp>
241 
    void
242 
    fill(_FIter, _FIter, const _Tp&);
243 
 
244 
  template<typename _OIter, typename _Size, typename _Tp>
245 
    _OIter
246 
    fill_n(_OIter, _Size, const _Tp&);
247 
 
248 
  // find
249 
 
250 
  template<typename _FIter1, typename _FIter2>
251 
    _FIter1
252 
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
253 
 
254 
  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
255 
    _FIter1
256 
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
257 
 
258 
  // find_first_of
259 
  // find_if
260 
 
261 
#if __cplusplus >= 201103L
262 
  template<typename _IIter, typename _Predicate>
263 
    _IIter
264 
    find_if_not(_IIter, _IIter, _Predicate);
265 
#endif
266 
 
267 
  // for_each
268 
  // generate
269 
  // generate_n
270 
 
271 
  template<typename _IIter1, typename _IIter2>
272 
    bool
273 
    includes(_IIter1, _IIter1, _IIter2, _IIter2);
274 
 
275 
  template<typename _IIter1, typename _IIter2, typename _Compare>
276 
    bool
277 
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
278 
 
279 
  template<typename _BIter>
280 
    void
281 
    inplace_merge(_BIter, _BIter, _BIter);
282 
 
283 
  template<typename _BIter, typename _Compare>
284 
    void
285 
    inplace_merge(_BIter, _BIter, _BIter, _Compare);
286 
 
287 
#if __cplusplus >= 201103L
288 
  template<typename _RAIter>
289 
    bool
290 
    is_heap(_RAIter, _RAIter);
291 
 
292 
  template<typename _RAIter, typename _Compare>
293 
    bool
294 
    is_heap(_RAIter, _RAIter, _Compare);
295 
 
296 
  template<typename _RAIter>
297 
    _RAIter
298 
    is_heap_until(_RAIter, _RAIter);
299 
 
300 
  template<typename _RAIter, typename _Compare>
301 
    _RAIter
302 
    is_heap_until(_RAIter, _RAIter, _Compare);
303 
 
304 
  template<typename _IIter, typename _Predicate>
305 
    bool
306 
    is_partitioned(_IIter, _IIter, _Predicate);
307 
 
308 
  template<typename _FIter1, typename _FIter2>
309 
    bool
310 
    is_permutation(_FIter1, _FIter1, _FIter2);
311 
 
312 
  template<typename _FIter1, typename _FIter2,
313 
           typename _BinaryPredicate>
314 
    bool
315 
    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
316 
 
317 
  template<typename _FIter>
318 
    bool
319 
    is_sorted(_FIter, _FIter);
320 
 
321 
  template<typename _FIter, typename _Compare>
322 
    bool
323 
    is_sorted(_FIter, _FIter, _Compare);
324 
 
325 
  template<typename _FIter>
326 
    _FIter
327 
    is_sorted_until(_FIter, _FIter);
328 
 
329 
  template<typename _FIter, typename _Compare>
330 
    _FIter
331 
    is_sorted_until(_FIter, _FIter, _Compare);
332 
#endif
333 
 
334 
  template<typename _FIter1, typename _FIter2>
335 
    void
336 
    iter_swap(_FIter1, _FIter2);
337 
 
338 
  template<typename _FIter, typename _Tp>
339 
    _FIter
340 
    lower_bound(_FIter, _FIter, const _Tp&);
341 
 
342 
  template<typename _FIter, typename _Tp, typename _Compare>
343 
    _FIter
344 
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
345 
 
346 
  template<typename _RAIter>
347 
    void
348 
    make_heap(_RAIter, _RAIter);
349 
 
350 
  template<typename _RAIter, typename _Compare>
351 
    void
352 
    make_heap(_RAIter, _RAIter, _Compare);
353 
 
354 
  template<typename _Tp>
355 
    const _Tp&
356 
    max(const _Tp&, const _Tp&);
357 
 
358 
  template<typename _Tp, typename _Compare>
359 
    const _Tp&
360 
    max(const _Tp&, const _Tp&, _Compare);
361 
 
362 
  // max_element
363 
  // merge
364 
 
365 
  template<typename _Tp>
366 
    const _Tp&
367 
    min(const _Tp&, const _Tp&);
368 
 
369 
  template<typename _Tp, typename _Compare>
370 
    const _Tp&
371 
    min(const _Tp&, const _Tp&, _Compare);
372 
 
373 
  // min_element
374 
 
375 
#if __cplusplus >= 201103L
376 
  template<typename _Tp>
377 
    pair<const _Tp&, const _Tp&>
378 
    minmax(const _Tp&, const _Tp&);
379 
 
380 
  template<typename _Tp, typename _Compare>
381 
    pair<const _Tp&, const _Tp&>
382 
    minmax(const _Tp&, const _Tp&, _Compare);
383 
 
384 
  template<typename _FIter>
385 
    pair<_FIter, _FIter>
386 
    minmax_element(_FIter, _FIter);
387 
 
388 
  template<typename _FIter, typename _Compare>
389 
    pair<_FIter, _FIter>
390 
    minmax_element(_FIter, _FIter, _Compare);
391 
 
392 
  template<typename _Tp>
393 
    _Tp
394 
    min(initializer_list<_Tp>);
395 
 
396 
  template<typename _Tp, typename _Compare>
397 
    _Tp
398 
    min(initializer_list<_Tp>, _Compare);
399 
 
400 
  template<typename _Tp>
401 
    _Tp
402 
    max(initializer_list<_Tp>);
403 
 
404 
  template<typename _Tp, typename _Compare>
405 
    _Tp
406 
    max(initializer_list<_Tp>, _Compare);
407 
 
408 
  template<typename _Tp>
409 
    pair<_Tp, _Tp>
410 
    minmax(initializer_list<_Tp>);
411 
 
412 
  template<typename _Tp, typename _Compare>
413 
    pair<_Tp, _Tp>
414 
    minmax(initializer_list<_Tp>, _Compare);
415 
#endif
416 
 
417 
  // mismatch
418 
 
419 
  template<typename _BIter>
420 
    bool
421 
    next_permutation(_BIter, _BIter);
422 
 
423 
  template<typename _BIter, typename _Compare>
424 
    bool
425 
    next_permutation(_BIter, _BIter, _Compare);
426 
 
427 
#if __cplusplus >= 201103L
428 
  template<typename _IIter, typename _Predicate>
429 
    bool
430 
    none_of(_IIter, _IIter, _Predicate);
431 
#endif
432 
 
433 
  // nth_element
434 
  // partial_sort
435 
 
436 
  template<typename _IIter, typename _RAIter>
437 
    _RAIter
438 
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
439 
 
440 
  template<typename _IIter, typename _RAIter, typename _Compare>
441 
    _RAIter
442 
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
443 
 
444 
  // partition
445 
 
446 
#if __cplusplus >= 201103L
447 
  template<typename _IIter, typename _OIter1,
448 
           typename _OIter2, typename _Predicate>
449 
    pair<_OIter1, _OIter2>
450 
    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
451 
 
452 
  template<typename _FIter, typename _Predicate>
453 
    _FIter
454 
    partition_point(_FIter, _FIter, _Predicate);
455 
#endif
456 
 
457 
  template<typename _RAIter>
458 
    void
459 
    pop_heap(_RAIter, _RAIter);
460 
 
461 
  template<typename _RAIter, typename _Compare>
462 
    void
463 
    pop_heap(_RAIter, _RAIter, _Compare);
464 
 
465 
  template<typename _BIter>
466 
    bool
467 
    prev_permutation(_BIter, _BIter);
468 
 
469 
  template<typename _BIter, typename _Compare>
470 
    bool
471 
    prev_permutation(_BIter, _BIter, _Compare);
472 
 
473 
  template<typename _RAIter>
474 
    void
475 
    push_heap(_RAIter, _RAIter);
476 
 
477 
  template<typename _RAIter, typename _Compare>
478 
    void
479 
    push_heap(_RAIter, _RAIter, _Compare);
480 
 
481 
  // random_shuffle
482 
 
483 
  template<typename _FIter, typename _Tp>
484 
    _FIter
485 
    remove(_FIter, _FIter, const _Tp&);
486 
 
487 
  template<typename _FIter, typename _Predicate>
488 
    _FIter
489 
    remove_if(_FIter, _FIter, _Predicate);
490 
 
491 
  template<typename _IIter, typename _OIter, typename _Tp>
492 
    _OIter
493 
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
494 
 
495 
  template<typename _IIter, typename _OIter, typename _Predicate>
496 
    _OIter
497 
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
498 
 
499 
  // replace
500 
 
501 
  template<typename _IIter, typename _OIter, typename _Tp>
502 
    _OIter
503 
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
504 
 
505 
  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
506 
    _OIter
507 
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
508 
 
509 
  // replace_if
510 
 
511 
  template<typename _BIter>
512 
    void
513 
    reverse(_BIter, _BIter);
514 
 
515 
  template<typename _BIter, typename _OIter>
516 
    _OIter
517 
    reverse_copy(_BIter, _BIter, _OIter);
518 
 
519 
  template<typename _FIter>
520 
    void
521 
    rotate(_FIter, _FIter, _FIter);
522 
 
523 
  template<typename _FIter, typename _OIter>
524 
    _OIter
525 
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
526 
 
527 
  // search
528 
  // search_n
529 
  // set_difference
530 
  // set_intersection
531 
  // set_symmetric_difference
532 
  // set_union
533 
 
534 
#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
535 
  template<typename _RAIter, typename _UGenerator>
536 
    void
537 
    shuffle(_RAIter, _RAIter, _UGenerator&&);
538 
#endif
539 
 
540 
  template<typename _RAIter>
541 
    void
542 
    sort_heap(_RAIter, _RAIter);
543 
 
544 
  template<typename _RAIter, typename _Compare>
545 
    void
546 
    sort_heap(_RAIter, _RAIter, _Compare);
547 
 
548 
  template<typename _BIter, typename _Predicate>
549 
    _BIter
550 
    stable_partition(_BIter, _BIter, _Predicate);
551 
 
552 
  template<typename _Tp>
553 
    void
554 
    swap(_Tp&, _Tp&)
555 
#if __cplusplus >= 201103L
556 
    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
557 
                    is_nothrow_move_assignable<_Tp>>::value)
558 
#endif
559 
    ;
560 
 
561 
  template<typename _Tp, size_t _Nm>
562 
    void
563 
    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
564 
#if __cplusplus >= 201103L
565 
    noexcept(noexcept(swap(*__a, *__b)))
566 
#endif
567 
    ;
568 
 
569 
  template<typename _FIter1, typename _FIter2>
570 
    _FIter2
571 
    swap_ranges(_FIter1, _FIter1, _FIter2);
572 
 
573 
  // transform
574 
 
575 
  template<typename _FIter>
576 
    _FIter
577 
    unique(_FIter, _FIter);
578 
 
579 
  template<typename _FIter, typename _BinaryPredicate>
580 
    _FIter
581 
    unique(_FIter, _FIter, _BinaryPredicate);
582 
 
583 
  // unique_copy
584 
 
585 
  template<typename _FIter, typename _Tp>
586 
    _FIter
587 
    upper_bound(_FIter, _FIter, const _Tp&);
588 
 
589 
  template<typename _FIter, typename _Tp, typename _Compare>
590 
    _FIter
591 
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
592 
 
593 
_GLIBCXX_END_NAMESPACE_VERSION
594 
 
595 
_GLIBCXX_BEGIN_NAMESPACE_ALGO
596 
 
597 
  template<typename _FIter>
598 
    _FIter
599 
    adjacent_find(_FIter, _FIter);
600 
 
601 
  template<typename _FIter, typename _BinaryPredicate>
602 
    _FIter
603 
    adjacent_find(_FIter, _FIter, _BinaryPredicate);
604 
 
605 
  template<typename _IIter, typename _Tp>
606 
    typename iterator_traits<_IIter>::difference_type
607 
    count(_IIter, _IIter, const _Tp&);
608 
 
609 
  template<typename _IIter, typename _Predicate>
610 
    typename iterator_traits<_IIter>::difference_type
611 
    count_if(_IIter, _IIter, _Predicate);
612 
 
613 
  template<typename _IIter1, typename _IIter2>
614 
    bool
615 
    equal(_IIter1, _IIter1, _IIter2);
616 
 
617 
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
618 
    bool
619 
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
620 
 
621 
  template<typename _IIter, typename _Tp>
622 
    _IIter
623 
    find(_IIter, _IIter, const _Tp&);
624 
 
625 
  template<typename _FIter1, typename _FIter2>
626 
    _FIter1
627 
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
628 
 
629 
  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
630 
    _FIter1
631 
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
632 
 
633 
  template<typename _IIter, typename _Predicate>
634 
    _IIter
635 
    find_if(_IIter, _IIter, _Predicate);
636 
 
637 
  template<typename _IIter, typename _Funct>
638 
    _Funct
639 
    for_each(_IIter, _IIter, _Funct);
640 
 
641 
  template<typename _FIter, typename _Generator>
642 
    void
643 
    generate(_FIter, _FIter, _Generator);
644 
 
645 
  template<typename _OIter, typename _Size, typename _Generator>
646 
    _OIter
647 
    generate_n(_OIter, _Size, _Generator);
648 
 
649 
  template<typename _IIter1, typename _IIter2>
650 
    bool
651 
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
652 
 
653 
  template<typename _IIter1, typename _IIter2, typename _Compare>
654 
    bool
655 
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
656 
 
657 
  template<typename _FIter>
658 
    _FIter
659 
    max_element(_FIter, _FIter);
660 
 
661 
  template<typename _FIter, typename _Compare>
662 
    _FIter
663 
    max_element(_FIter, _FIter, _Compare);
664 
 
665 
  template<typename _IIter1, typename _IIter2, typename _OIter>
666 
    _OIter
667 
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
668 
 
669 
  template<typename _IIter1, typename _IIter2, typename _OIter,
670 
           typename _Compare>
671 
    _OIter
672 
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
673 
 
674 
  template<typename _FIter>
675 
    _FIter
676 
    min_element(_FIter, _FIter);
677 
 
678 
  template<typename _FIter, typename _Compare>
679 
    _FIter
680 
    min_element(_FIter, _FIter, _Compare);
681 
 
682 
  template<typename _IIter1, typename _IIter2>
683 
    pair<_IIter1, _IIter2>
684 
    mismatch(_IIter1, _IIter1, _IIter2);
685 
 
686 
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
687 
    pair<_IIter1, _IIter2>
688 
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
689 
 
690 
  template<typename _RAIter>
691 
    void
692 
    nth_element(_RAIter, _RAIter, _RAIter);
693 
 
694 
  template<typename _RAIter, typename _Compare>
695 
    void
696 
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
697 
 
698 
  template<typename _RAIter>
699 
    void
700 
    partial_sort(_RAIter, _RAIter, _RAIter);
701 
 
702 
  template<typename _RAIter, typename _Compare>
703 
    void
704 
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
705 
 
706 
  template<typename _BIter, typename _Predicate>
707 
    _BIter
708 
    partition(_BIter, _BIter, _Predicate);
709 
 
710 
  template<typename _RAIter>
711 
    void
712 
    random_shuffle(_RAIter, _RAIter);
713 
 
714 
  template<typename _RAIter, typename _Generator>
715 
    void
716 
    random_shuffle(_RAIter, _RAIter,
717 
#if __cplusplus >= 201103L
718 
                   _Generator&&);
719 
#else
720 
                   _Generator&);
721 
#endif
722 
 
723 
  template<typename _FIter, typename _Tp>
724 
    void
725 
    replace(_FIter, _FIter, const _Tp&, const _Tp&);
726 
 
727 
  template<typename _FIter, typename _Predicate, typename _Tp>
728 
    void
729 
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
730 
 
731 
  template<typename _FIter1, typename _FIter2>
732 
    _FIter1
733 
    search(_FIter1, _FIter1, _FIter2, _FIter2);
734 
 
735 
  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
736 
    _FIter1
737 
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
738 
 
739 
  template<typename _FIter, typename _Size, typename _Tp>
740 
    _FIter
741 
    search_n(_FIter, _FIter, _Size, const _Tp&);
742 
 
743 
  template<typename _FIter, typename _Size, typename _Tp,
744 
           typename _BinaryPredicate>
745 
    _FIter
746 
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
747 
 
748 
  template<typename _IIter1, typename _IIter2, typename _OIter>
749 
    _OIter
750 
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
751 
 
752 
  template<typename _IIter1, typename _IIter2, typename _OIter,
753 
           typename _Compare>
754 
    _OIter
755 
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
756 
 
757 
  template<typename _IIter1, typename _IIter2, typename _OIter>
758 
    _OIter
759 
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
760 
 
761 
  template<typename _IIter1, typename _IIter2, typename _OIter,
762 
           typename _Compare>
763 
    _OIter
764 
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
765 
 
766 
  template<typename _IIter1, typename _IIter2, typename _OIter>
767 
    _OIter
768 
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
769 
 
770 
  template<typename _IIter1, typename _IIter2, typename _OIter,
771 
           typename _Compare>
772 
    _OIter
773 
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
774 
                             _OIter, _Compare);
775 
 
776 
  template<typename _IIter1, typename _IIter2, typename _OIter>
777 
    _OIter
778 
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
779 
 
780 
  template<typename _IIter1, typename _IIter2, typename _OIter,
781 
           typename _Compare>
782 
    _OIter
783 
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
784 
 
785 
  template<typename _RAIter>
786 
    void
787 
    sort(_RAIter, _RAIter);
788 
 
789 
  template<typename _RAIter, typename _Compare>
790 
    void
791 
    sort(_RAIter, _RAIter, _Compare);
792 
 
793 
  template<typename _RAIter>
794 
    void
795 
    stable_sort(_RAIter, _RAIter);
796 
 
797 
  template<typename _RAIter, typename _Compare>
798 
    void
799 
    stable_sort(_RAIter, _RAIter, _Compare);
800 
 
801 
  template<typename _IIter, typename _OIter, typename _UnaryOperation>
802 
    _OIter
803 
    transform(_IIter, _IIter, _OIter, _UnaryOperation);
804 
 
805 
  template<typename _IIter1, typename _IIter2, typename _OIter,
806 
           typename _BinaryOperation>
807 
    _OIter
808 
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
809 
 
810 
  template<typename _IIter, typename _OIter>
811 
    _OIter
812 
    unique_copy(_IIter, _IIter, _OIter);
813 
 
814 
  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
815 
    _OIter
816 
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
817 
 
818 
_GLIBCXX_END_NAMESPACE_ALGO
819 
} // namespace std
820 
 
821 
#ifdef _GLIBCXX_PARALLEL
822 
# include <parallel/algorithmfwd.h>
823 
#endif
824 
 
825 
#endif
826 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.