sort_heap complexity guarantee

[FranÃois Dumont <frs dot dumont at gmail dot com>]

Hi

    I took a look at PR 61217 regarding pop_heap complexity guarantee. 
Looks like we have no test to check complexity of our algos so I start 
writing some starting with the heap operations. I found no issue with 
make_heap, push_heap and pop_heap despite what the bug report is saying 
however the attached testcase for sort_heap is failing.

    Standard is saying std::sort_heap shall use less than N * log(N) 
comparisons but with my test using 1000 random values the test is showing:

8687 comparisons on 6907.76 max allowed

    Is this a known issue of sort_heap ? Do you confirm that the test 
is valid ?

    Note that counter_type needs a patch to make the test ok, 
less_compare_count must be updated when operator< is invoked.

Thanks

FranÃois

// Copyright (C) 2014 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.

// { dg-options "-std=gnu++11" }

#include <iostream>

#include <cmath>
#include <random>
#include <vector>
#include <algorithm>

#include <testsuite_counter_type.h>
#include <testsuite_hooks.h>

void test01()
{
  using __gnu_test::counter_type;
  const std::size_t nb_values = 1000;

  std::random_device dev;
  std::uniform_int_distribution<int> dist;
  std::vector<counter_type> values;
  values.reserve(nb_values);
  for (std::size_t i = 0; i != nb_values; ++i)
    values.push_back(dist(dev));

  std::make_heap(values.begin(), values.end());

  counter_type::reset();

  std::sort_heap(values.begin(), values.end());

  std::cout << counter_type::less_compare_count << " comparisons";
  std::cout << " on " << nb_values * std::log(nb_values) << " max allowed" << std::endl;

  VERIFY( counter_type::less_compare_count <= nb_values * std::log(nb_values) );
}

int main()
{
  test01();
  return 0;
}