libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc

   1 // { dg-do compile }
   2
   3 // Copyright (C) 2007-2020 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING3.  If not see
  18 // <http://www.gnu.org/licenses/>.
  19
  20 #include <algorithm>
  21
  22 namespace std
  23  {
  24   // 25.1, non-modifying sequence operations:
  25   template<typename _IIter, typename _Funct>
  26     _GLIBCXX20_CONSTEXPR
  27     _Funct
  28     for_each(_IIter, _IIter, _Funct);
  29
  30   template<typename _IIter, typename _Tp>
  31     _GLIBCXX20_CONSTEXPR
  32     _IIter
  33     find(_IIter, _IIter, const _Tp&);
  34
  35   template<typename _IIter, typename _Predicate>
  36     _GLIBCXX20_CONSTEXPR
  37     _IIter
  38     find_if(_IIter, _IIter, _Predicate);
  39
  40 #if __cplusplus >= 201103L
  41   template<typename _IIter, typename _Predicate>
  42     _GLIBCXX20_CONSTEXPR
  43     bool
  44     all_of(_IIter, _IIter, _Predicate);
  45
  46   template<typename _IIter, typename _Predicate>
  47     _GLIBCXX20_CONSTEXPR
  48     bool
  49     any_of(_IIter, _IIter, _Predicate);
  50
  51   template<typename _IIter, typename _Predicate>
  52     _GLIBCXX20_CONSTEXPR
  53     bool
  54     none_of(_IIter, _IIter, _Predicate);
  55
  56   template<typename _IIter, typename _Predicate>
  57     _GLIBCXX20_CONSTEXPR
  58     _IIter
  59     find_if_not(_IIter, _IIter, _Predicate);
  60
  61   template<typename _IIter, typename _Predicate>
  62     _GLIBCXX20_CONSTEXPR
  63     bool
  64     is_partitioned(_IIter, _IIter, _Predicate);
  65
  66   template<typename _FIter, typename _Predicate>
  67     _GLIBCXX20_CONSTEXPR
  68     _FIter
  69     partition_point(_FIter, _FIter, _Predicate);
  70 #endif
  71
  72   template<typename _FIter1, typename _FIter2>
  73     _GLIBCXX20_CONSTEXPR
  74     _FIter1
  75     find_end(_FIter1, _FIter1, _FIter2, _FIter2);
  76
  77   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
  78     _GLIBCXX20_CONSTEXPR
  79     _FIter1
  80     find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
  81
  82   template<typename _FIter1, typename _FIter2>
  83     _GLIBCXX20_CONSTEXPR
  84     _FIter1
  85     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
  86
  87   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
  88     _GLIBCXX20_CONSTEXPR
  89     _FIter1
  90     find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
  91
  92   template<typename _FIter>
  93     _GLIBCXX20_CONSTEXPR
  94     _FIter
  95     adjacent_find(_FIter, _FIter);
  96
  97   template<typename _FIter, typename _BinaryPredicate>
  98     _GLIBCXX20_CONSTEXPR
  99     _FIter
 100     adjacent_find(_FIter, _FIter, _BinaryPredicate);
 101
 102   template<typename _IIter, typename _Tp>
 103     _GLIBCXX20_CONSTEXPR
 104     typename iterator_traits<_IIter>::difference_type
 105     count(_IIter, _IIter, const _Tp&);
 106
 107   template<typename _IIter, typename _Predicate>
 108     _GLIBCXX20_CONSTEXPR
 109     typename iterator_traits<_IIter>::difference_type
 110     count_if(_IIter, _IIter, _Predicate);
 111
 112   template<typename _IIter1, typename _IIter2>
 113     _GLIBCXX20_CONSTEXPR
 114     pair<_IIter1, _IIter2>
 115     mismatch(_IIter1, _IIter1, _IIter2);
 116
 117   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 118     _GLIBCXX20_CONSTEXPR
 119     pair<_IIter1, _IIter2>
 120     mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 121
 122   template<typename _IIter1, typename _IIter2>
 123     _GLIBCXX20_CONSTEXPR
 124     bool
 125     equal(_IIter1, _IIter1, _IIter2);
 126
 127   template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
 128     _GLIBCXX20_CONSTEXPR
 129     bool
 130     equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
 131
 132   template<typename _FIter1, typename _FIter2>
 133     _GLIBCXX20_CONSTEXPR
 134     _FIter1
 135     search(_FIter1, _FIter1, _FIter2, _FIter2);
 136
 137   template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
 138     _GLIBCXX20_CONSTEXPR
 139     _FIter1
 140     search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
 141
 142   template<typename _FIter, typename _Size, typename _Tp>
 143     _GLIBCXX20_CONSTEXPR
 144     _FIter
 145     search_n(_FIter, _FIter, _Size, const _Tp&);
 146
 147   template<typename _FIter, typename _Size, typename _Tp,
 148            typename _BinaryPredicate>
 149     _GLIBCXX20_CONSTEXPR
 150     _FIter
 151     search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
 152
 153   // 25.2, modifying sequence operations:
 154   // 25.2.1, copy:
 155   template<typename _IIter, typename _OIter>
 156     _GLIBCXX20_CONSTEXPR
 157     _OIter
 158     copy(_IIter, _IIter, _OIter);
 159
 160   template<typename _BIter1, typename _BIter2>
 161     _GLIBCXX20_CONSTEXPR
 162     _BIter2
 163     copy_backward (_BIter1, _BIter1, _BIter2);
 164
 165   // 25.2.2, swap:
 166 #if __cplusplus < 201103L
 167   template<typename _Tp>
 168     _GLIBCXX20_CONSTEXPR
 169     void
 170     swap(_Tp&, _Tp& b);
 171
 172   template<typename _Tp, size_t _Nm>
 173     _GLIBCXX20_CONSTEXPR
 174     void
 175     swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);
 176 #else
 177   // C++11 swap() has complicated SFINAE constraints, test signatures like so:
 178   void (*swap_scalars)(int&, int&) = &swap;
 179   void (*swap_arrays)(int(&)[5], int(&)[5]) = &swap;
 180 #endif
 181
 182   template<typename _FIter1, typename _FIter2>
 183     _GLIBCXX20_CONSTEXPR
 184     _FIter2
 185     swap_ranges(_FIter1 first1, _FIter1, _FIter2);
 186
 187   template<typename _FIter1, typename _FIter2>
 188     _GLIBCXX20_CONSTEXPR
 189     void
 190     iter_swap(_FIter1, _FIter2 b);
 191
 192   template<typename _IIter, typename _OIter, typename _UnaryOperation>
 193     _GLIBCXX20_CONSTEXPR
 194     _OIter
 195     transform(_IIter, _IIter, _OIter, _UnaryOperation op);
 196
 197   template<typename _IIter1, typename _IIter2, typename _OIter,
 198            typename _BinaryOperation>
 199     _GLIBCXX20_CONSTEXPR
 200     _OIter
 201     transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
 202
 203   template<typename _FIter, typename _Tp>
 204     _GLIBCXX20_CONSTEXPR
 205     void
 206     replace(_FIter, _FIter, const _Tp&, const _Tp&);
 207
 208   template<typename _FIter, typename _Predicate, typename _Tp>
 209     _GLIBCXX20_CONSTEXPR
 210     void
 211     replace_if(_FIter, _FIter, _Predicate, const _Tp&);
 212
 213   template<typename _IIter, typename _OIter, typename _Tp>
 214     _GLIBCXX20_CONSTEXPR
 215     _OIter
 216     replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
 217
 218   template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
 219     _GLIBCXX20_CONSTEXPR
 220     _OIter
 221     replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
 222
 223   template<typename _FIter, typename _Tp>
 224     _GLIBCXX20_CONSTEXPR
 225     void
 226     fill(_FIter, _FIter, const _Tp&);
 227
 228   template<typename _OIter, typename _Size, typename _Tp>
 229     _GLIBCXX20_CONSTEXPR
 230     void
 231     fill_n(_OIter, _Size n, const _Tp&);
 232
 233   template<typename _FIter, typename _Generator>
 234     _GLIBCXX20_CONSTEXPR
 235     void
 236     generate(_FIter, _FIter, _Generator);
 237
 238   template<typename _OIter, typename _Size, typename _Generator>
 239     _GLIBCXX20_CONSTEXPR
 240     void
 241     generate_n(_OIter, _Size, _Generator);
 242
 243   template<typename _FIter, typename _Tp>
 244     _GLIBCXX20_CONSTEXPR
 245     _FIter
 246     remove(_FIter, _FIter, const _Tp&);
 247
 248   template<typename _FIter, typename _Predicate>
 249     _GLIBCXX20_CONSTEXPR
 250     _FIter
 251     remove_if(_FIter, _FIter, _Predicate);
 252
 253   template<typename _IIter, typename _OIter, typename _Tp>
 254     _GLIBCXX20_CONSTEXPR
 255     _OIter
 256     remove_copy(_IIter, _IIter, _OIter, const _Tp&);
 257
 258   template<typename _IIter, typename _OIter, typename _Predicate>
 259     _GLIBCXX20_CONSTEXPR
 260     _OIter
 261     remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
 262
 263 #if __cplusplus >= 201103L
 264   template<typename _IIter, typename _OIter, typename _Predicate>
 265     _GLIBCXX20_CONSTEXPR
 266     _OIter
 267     copy_if(_IIter, _IIter, _OIter, _Predicate);
 268
 269   template<typename _IIter, typename _Size, typename _OIter>
 270     _GLIBCXX20_CONSTEXPR
 271     _OIter
 272     copy_n(_IIter, _Size, _OIter);
 273
 274   template<typename _IIter, typename _OIter1,
 275            typename _OIter2, typename _Predicate>
 276     _GLIBCXX20_CONSTEXPR
 277     pair<_OIter1, _OIter2>
 278     partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
 279 #endif
 280
 281   template<typename _FIter>
 282     _GLIBCXX20_CONSTEXPR
 283     _FIter
 284     unique(_FIter, _FIter);
 285
 286   template<typename _FIter, typename _BinaryPredicate>
 287     _GLIBCXX20_CONSTEXPR
 288     _FIter
 289     unique(_FIter, _FIter, _BinaryPredicate);
 290
 291   template<typename _IIter, typename _OIter>
 292     _GLIBCXX20_CONSTEXPR
 293     _OIter
 294     unique_copy(_IIter, _IIter, _OIter);
 295
 296   template<typename _IIter, typename _OIter, typename _BinaryPredicate>
 297     _GLIBCXX20_CONSTEXPR
 298     _OIter
 299     unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
 300
 301   template<typename _BIter>
 302     _GLIBCXX20_CONSTEXPR
 303     void
 304     reverse(_BIter, _BIter);
 305
 306   template<typename _BIter, typename _OIter>
 307     _GLIBCXX20_CONSTEXPR
 308     _OIter
 309     reverse_copy(_BIter, _BIter, _OIter);
 310
 311   template<typename _FIter>
 312     _GLIBCXX20_CONSTEXPR
 313     void
 314     rotate(_FIter, _FIter, _FIter);
 315
 316   template<typename _FIter, typename _OIter>
 317     _GLIBCXX20_CONSTEXPR
 318     _OIter
 319     rotate_copy (_FIter, _FIter, _FIter, _OIter);
 320
 321   template<typename _RAIter>
 322     void
 323     random_shuffle(_RAIter, _RAIter);
 324
 325   template<typename _RAIter, typename _Generator>
 326     void
 327     random_shuffle(_RAIter, _RAIter, _Generator&);
 328
 329   // 25.2.12, partitions:
 330   template<typename _BIter, typename _Predicate>
 331     _GLIBCXX20_CONSTEXPR
 332     _BIter
 333     partition(_BIter, _BIter, _Predicate);
 334
 335   template<typename _BIter, typename _Predicate>
 336     _BIter
 337     stable_partition(_BIter, _BIter, _Predicate);
 338
 339   // 25.3, sorting and related operations:
 340   // 25.3.1, sorting:
 341   template<typename _RAIter>
 342     _GLIBCXX20_CONSTEXPR
 343     void
 344     sort(_RAIter, _RAIter);
 345
 346   template<typename _RAIter, typename _Compare>
 347     _GLIBCXX20_CONSTEXPR
 348     void
 349     sort(_RAIter, _RAIter, _Compare);
 350
 351   template<typename _RAIter>
 352     void
 353     stable_sort(_RAIter, _RAIter);
 354
 355   template<typename _RAIter, typename _Compare>
 356     void
 357     stable_sort(_RAIter, _RAIter, _Compare);
 358
 359   template<typename _RAIter>
 360     _GLIBCXX20_CONSTEXPR
 361     void
 362     partial_sort(_RAIter, _RAIter, _RAIter);
 363
 364   template<typename _RAIter, typename _Compare>
 365     _GLIBCXX20_CONSTEXPR
 366     void
 367     partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
 368
 369   template<typename _IIter, typename _RAIter>
 370     _GLIBCXX20_CONSTEXPR
 371     _RAIter
 372     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
 373
 374   template<typename _IIter, typename _RAIter, typename _Compare>
 375     _GLIBCXX20_CONSTEXPR
 376     _RAIter
 377     partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
 378
 379   template<typename _RAIter>
 380     _GLIBCXX20_CONSTEXPR
 381     void
 382     nth_element(_RAIter, _RAIter, _RAIter);
 383
 384   template<typename _RAIter, typename _Compare>
 385     _GLIBCXX20_CONSTEXPR
 386     void
 387     nth_element(_RAIter, _RAIter, _RAIter, _Compare);
 388
 389   // 25.3.3, binary search:
 390   template<typename _FIter, typename _Tp>
 391     _GLIBCXX20_CONSTEXPR
 392     _FIter
 393     lower_bound(_FIter, _FIter, const _Tp&);
 394
 395   template<typename _FIter, typename _Tp, typename _Compare>
 396     _GLIBCXX20_CONSTEXPR
 397     _FIter
 398     lower_bound(_FIter, _FIter, const _Tp&, _Compare);
 399
 400   template<typename _FIter, typename _Tp>
 401     _GLIBCXX20_CONSTEXPR
 402     _FIter
 403     upper_bound(_FIter, _FIter, const _Tp&);
 404
 405   template<typename _FIter, typename _Tp, typename _Compare>
 406     _GLIBCXX20_CONSTEXPR
 407     _FIter
 408     upper_bound(_FIter, _FIter, const _Tp&, _Compare);
 409
 410   template<typename _FIter, typename _Tp>
 411     _GLIBCXX20_CONSTEXPR
 412     pair<_FIter, _FIter>
 413     equal_range(_FIter, _FIter, const _Tp&);
 414
 415   template<typename _FIter, typename _Tp, typename _Compare>
 416     _GLIBCXX20_CONSTEXPR
 417     pair<_FIter, _FIter>
 418     equal_range(_FIter, _FIter, const _Tp&, _Compare);
 419
 420   template<typename _FIter, typename _Tp>
 421     _GLIBCXX20_CONSTEXPR
 422     bool
 423     binary_search(_FIter, _FIter, const _Tp&);
 424
 425   template<typename _FIter, typename _Tp, typename _Compare>
 426     _GLIBCXX20_CONSTEXPR
 427     bool
 428     binary_search(_FIter, _FIter, const _Tp&, _Compare);
 429
 430   // 25.3.4, merge:
 431   template<typename _IIter1, typename _IIter2, typename _OIter>
 432     _GLIBCXX20_CONSTEXPR
 433     _OIter
 434     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 435
 436   template<typename _IIter1, typename _IIter2, typename _OIter,
 437            typename _Compare>
 438     _GLIBCXX20_CONSTEXPR
 439     _OIter
 440     merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 441
 442   template<typename _BIter>
 443     void
 444     inplace_merge(_BIter, _BIter, _BIter);
 445
 446   template<typename _BIter, typename _Compare>
 447     void
 448     inplace_merge(_BIter, _BIter, _BIter, _Compare);
 449
 450   // 25.3.5, set operations:
 451   template<typename _IIter1, typename _IIter2>
 452     _GLIBCXX20_CONSTEXPR
 453     bool
 454     includes(_IIter1, _IIter1, _IIter2, _IIter2);
 455
 456   template<typename _IIter1, typename _IIter2, typename _Compare>
 457     _GLIBCXX20_CONSTEXPR
 458     bool
 459     includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 460
 461   template<typename _IIter1, typename _IIter2, typename _OIter>
 462     _GLIBCXX20_CONSTEXPR
 463     _OIter
 464     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 465
 466   template<typename _IIter1, typename _IIter2, typename _OIter,
 467            typename _Compare>
 468     _GLIBCXX20_CONSTEXPR
 469     _OIter
 470     set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 471
 472   template<typename _IIter1, typename _IIter2, typename _OIter>
 473     _GLIBCXX20_CONSTEXPR
 474     _OIter
 475     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 476
 477   template<typename _IIter1, typename _IIter2, typename _OIter,
 478            typename _Compare>
 479     _GLIBCXX20_CONSTEXPR
 480     _OIter
 481     set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 482
 483   template<typename _IIter1, typename _IIter2, typename _OIter>
 484     _GLIBCXX20_CONSTEXPR
 485     _OIter
 486     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 487
 488   template<typename _IIter1, typename _IIter2, typename _OIter,
 489            typename _Compare>
 490     _GLIBCXX20_CONSTEXPR
 491     _OIter
 492     set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
 493
 494   template<typename _IIter1, typename _IIter2, typename _OIter>
 495     _GLIBCXX20_CONSTEXPR
 496     _OIter
 497     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
 498
 499   template<typename _IIter1, typename _IIter2, typename _OIter,
 500            typename _Compare>
 501     _GLIBCXX20_CONSTEXPR
 502     _OIter
 503     set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
 504                              _OIter, _Compare);
 505
 506   // 25.3.6, heap operations:
 507   template<typename _RAIter>
 508     _GLIBCXX20_CONSTEXPR
 509     void
 510     push_heap(_RAIter, _RAIter);
 511
 512   template<typename _RAIter, typename _Compare>
 513     _GLIBCXX20_CONSTEXPR
 514     void
 515     push_heap(_RAIter, _RAIter, _Compare);
 516
 517   template<typename _RAIter>
 518     _GLIBCXX20_CONSTEXPR
 519     void
 520     pop_heap(_RAIter, _RAIter);
 521
 522   template<typename _RAIter, typename _Compare>
 523     _GLIBCXX20_CONSTEXPR
 524     void
 525     pop_heap(_RAIter, _RAIter, _Compare);
 526
 527   template<typename _RAIter>
 528     _GLIBCXX20_CONSTEXPR
 529     void
 530     make_heap(_RAIter, _RAIter);
 531
 532   template<typename _RAIter, typename _Compare>
 533     _GLIBCXX20_CONSTEXPR
 534     void
 535     make_heap(_RAIter, _RAIter, _Compare);
 536
 537   template<typename _RAIter>
 538     _GLIBCXX20_CONSTEXPR
 539     void
 540     sort_heap(_RAIter, _RAIter);
 541
 542   template<typename _RAIter, typename _Compare>
 543     _GLIBCXX20_CONSTEXPR
 544     void
 545     sort_heap(_RAIter, _RAIter, _Compare);
 546
 547 #if __cplusplus >= 201103L
 548   template<typename _RAIter>
 549     _GLIBCXX20_CONSTEXPR
 550     bool
 551     is_heap(_RAIter, _RAIter);
 552
 553   template<typename _RAIter, typename _Compare>
 554     _GLIBCXX20_CONSTEXPR
 555     bool
 556     is_heap(_RAIter, _RAIter, _Compare);
 557
 558   template<typename _RAIter>
 559     _GLIBCXX20_CONSTEXPR
 560     _RAIter
 561     is_heap_until(_RAIter, _RAIter);
 562
 563   template<typename _RAIter, typename _Compare>
 564     _GLIBCXX20_CONSTEXPR
 565     _RAIter
 566     is_heap_until(_RAIter, _RAIter, _Compare);
 567
 568   template<typename _FIter>
 569     _GLIBCXX20_CONSTEXPR
 570     bool
 571     is_sorted(_FIter, _FIter);
 572
 573   template<typename _FIter, typename _Compare>
 574     _GLIBCXX20_CONSTEXPR
 575     bool
 576     is_sorted(_FIter, _FIter, _Compare);
 577
 578   template<typename _FIter>
 579     _GLIBCXX20_CONSTEXPR
 580     _FIter
 581     is_sorted_until(_FIter, _FIter);
 582
 583   template<typename _FIter, typename _Compare>
 584     _GLIBCXX20_CONSTEXPR
 585     _FIter
 586     is_sorted_until(_FIter, _FIter, _Compare);
 587 #endif
 588
 589   // 25.3.7, minimum and maximum:
 590   template<typename _Tp>
 591     _GLIBCXX14_CONSTEXPR
 592     const _Tp&
 593     min(const _Tp&, const _Tp&);
 594
 595   template<typename _Tp, typename _Compare>
 596     _GLIBCXX14_CONSTEXPR
 597     const _Tp&
 598     min(const _Tp&, const _Tp&, _Compare);
 599
 600   template<typename _Tp>
 601     _GLIBCXX14_CONSTEXPR
 602     const _Tp&
 603     max(const _Tp&, const _Tp&);
 604
 605   template<typename _Tp, typename _Compare>
 606     _GLIBCXX14_CONSTEXPR
 607     const _Tp&
 608     max(const _Tp&, const _Tp&, _Compare);
 609
 610   template<typename _FIter>
 611     _GLIBCXX14_CONSTEXPR
 612     _FIter
 613     min_element(_FIter, _FIter);
 614
 615   template<typename _FIter, typename _Compare>
 616     _GLIBCXX14_CONSTEXPR
 617     _FIter
 618     min_element(_FIter, _FIter, _Compare);
 619
 620   template<typename _FIter>
 621     _GLIBCXX14_CONSTEXPR
 622     _FIter
 623     max_element(_FIter, _FIter);
 624
 625   template<typename _FIter, typename _Compare>
 626     _GLIBCXX14_CONSTEXPR
 627     _FIter
 628     max_element(_FIter, _FIter, _Compare);
 629
 630 #if __cplusplus >= 201103L
 631   template<typename _Tp>
 632     _GLIBCXX14_CONSTEXPR
 633     pair<const _Tp&, const _Tp&>
 634     minmax(const _Tp&, const _Tp&);
 635
 636   template<typename _Tp, typename _Compare>
 637     _GLIBCXX14_CONSTEXPR
 638     pair<const _Tp&, const _Tp&>
 639     minmax(const _Tp&, const _Tp&, _Compare);
 640
 641   template<typename _FIter>
 642     _GLIBCXX14_CONSTEXPR
 643     pair<_FIter, _FIter>
 644     minmax_element(_FIter, _FIter);
 645
 646   template<typename _FIter, typename _Compare>
 647     _GLIBCXX14_CONSTEXPR
 648     pair<_FIter, _FIter>
 649     minmax_element(_FIter, _FIter, _Compare);
 650
 651   template<typename _Tp>
 652     _GLIBCXX14_CONSTEXPR
 653     _Tp
 654     min(initializer_list<_Tp>);
 655
 656   template<typename _Tp, typename _Compare>
 657     _GLIBCXX14_CONSTEXPR
 658     _Tp
 659     min(initializer_list<_Tp>, _Compare);
 660
 661   template<typename _Tp>
 662     _GLIBCXX14_CONSTEXPR
 663     _Tp
 664     max(initializer_list<_Tp>);
 665
 666   template<typename _Tp, typename _Compare>
 667     _GLIBCXX14_CONSTEXPR
 668     _Tp
 669     max(initializer_list<_Tp>, _Compare);
 670
 671   template<typename _Tp>
 672     _GLIBCXX14_CONSTEXPR
 673     pair<_Tp, _Tp>
 674     minmax(initializer_list<_Tp>);
 675
 676   template<typename _Tp, typename _Compare>
 677     _GLIBCXX14_CONSTEXPR
 678     pair<_Tp, _Tp>
 679     minmax(initializer_list<_Tp>, _Compare);
 680 #endif
 681
 682   template<typename _IIter1, typename _IIter2>
 683     _GLIBCXX20_CONSTEXPR
 684     bool
 685     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
 686
 687   template<typename _IIter1, typename _IIter2, typename _Compare>
 688     _GLIBCXX20_CONSTEXPR
 689     bool
 690     lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
 691
 692   // 25.3.9, permutations
 693   template<typename _BIter>
 694     _GLIBCXX20_CONSTEXPR
 695     bool
 696     next_permutation(_BIter, _BIter);
 697
 698   template<typename _BIter, typename _Compare>
 699     _GLIBCXX20_CONSTEXPR
 700     bool
 701     next_permutation(_BIter, _BIter, _Compare);
 702
 703   template<typename _BIter>
 704     _GLIBCXX20_CONSTEXPR
 705     bool
 706     prev_permutation(_BIter, _BIter);
 707
 708   template<typename _BIter, typename _Compare>
 709     _GLIBCXX20_CONSTEXPR
 710     bool
 711     prev_permutation(_BIter, _BIter, _Compare);
 712 }