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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [libstdc++-v3/] [include/] [bits/] [algorithmfwd.h] - Blame information for rev 826

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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