Added additional tests, benchmarks, and overflow checks

Author: mborland

include/boost/math/special_functions/prime_functions.hpp renamed to include/boost/math/special_functions/prime_sieve.hpp

@@ -13,6 +13,7 @@
 #include <deque>
 #include <vector>
 #include <iterator>
+#include <iostream>
 
 namespace boost { namespace math
 {
@@ -23,6 +24,7 @@ template<class Z, class OutputIterator>
 auto prime_sieve(Z lower_bound, Z upper_bound, OutputIterator output) -> decltype(output)
 {
     static_assert(std::is_integral<Z>::value, "No primes for floating point types");
+    BOOST_ASSERT_MSG(upper_bound + 1 < std::numeric_limits<Z>::max(), "Type Overflow");
     std::vector<Z> least_divisors(upper_bound + 1, 0);
     std::deque<Z> primes;
 

reporting/performance/prime_functions_performance.cpp renamed to reporting/performance/prime_sieve_performance.cpp

@@ -5,8 +5,7 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include "../../include/boost/math/special_functions/prime_functions.hpp"
-
+#include <boost/math/special_functions/prime_sieve.hpp>
 #include <benchmark/benchmark.h>
 
 template <class Z>
@@ -18,6 +17,19 @@ void prime_sieve(benchmark::State& state)
         std::vector<Z> primes;
         benchmark::DoNotOptimize(boost::math::prime_sieve(static_cast<Z>(2), upper, std::back_inserter(primes)));
     }
+    state.SetComplexityN(state.range(0));
+}
+
+template <typename Z>
+void prime_range(benchmark::State& state)
+{
+    Z upper = static_cast<Z>(state.range(0));
+    for(auto _ : state)
+    {
+        std::vector<Z> primes;
+        benchmark::DoNotOptimize(boost::math::prime_range(static_cast<Z>(2), upper, std::back_inserter(primes)));
+    }
+    state.SetComplexityN(state.range(0));
 }
 
 template <class Z>
@@ -30,6 +42,7 @@ void prime_sieve_partial_range(benchmark::State& state)
         std::vector<Z> primes;
         benchmark::DoNotOptimize(boost::math::prime_sieve(lower, upper, std::back_inserter(primes)));
     }
+    state.SetComplexityN(state.range(0));
 }
 
 BENCHMARK_TEMPLATE(prime_sieve, int32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
@@ -38,5 +51,16 @@ BENCHMARK_TEMPLATE(prime_sieve, uint32_t)->RangeMultiplier(2)->Range(1 << 1, 1 <
 BENCHMARK_TEMPLATE(prime_sieve_partial_range, int32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
 BENCHMARK_TEMPLATE(prime_sieve_partial_range, int64_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
 BENCHMARK_TEMPLATE(prime_sieve_partial_range, uint32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, int32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, int64_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, uint32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 22)->Complexity();
+
+// Direct comparison of lookup vs sieve using only range of lookup
+BENCHMARK_TEMPLATE(prime_sieve, int32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, int32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
+BENCHMARK_TEMPLATE(prime_sieve, int64_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, int64_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
+BENCHMARK_TEMPLATE(prime_sieve, uint32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
+BENCHMARK_TEMPLATE(prime_range, uint32_t)->RangeMultiplier(2)->Range(1 << 1, 1 << 16)->Complexity();
 
 BENCHMARK_MAIN();

test/test_prime_functions.cpp renamed to test/test_prime_sieve.cpp

@@ -5,9 +5,9 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include "../include/boost/math/special_functions/prime_functions.hpp"
-
+#include <boost/math/special_functions/prime_sieve.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
 #include <list>
 #include <deque>
 #include <array>
@@ -97,6 +97,16 @@ void test_prime_range()
     BOOST_TEST_EQ(primes.size(), ref);
 }
 
+template<typename Z>
+void test_prime_sieve_overflow()
+{
+    std::vector<Z> primes;
+
+    // Should die with call to BOOST_ASSERT
+    boost::math::prime_sieve(static_cast<Z>(2), static_cast<Z>(std::numeric_limits<Z>::max()),
+                             std::back_inserter(primes));
+}
+
 int main()
 {
     test_prime_sieve<int>();
@@ -109,5 +119,9 @@ int main()
     test_prime_range<int64_t>();
     test_prime_range<uint32_t>();
 
+    test_prime_sieve<boost::multiprecision::cpp_int>();
+
+    //test_prime_sieve_overflow<int16_t>();
+
     boost::report_errors();
 }