- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
#include <iostream>
#include <thread>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <iterator>
#include <future>
constexpr std::size_t array_size = 1e7;
constexpr std::size_t chunks_number = 1e3;
double local_pi(const std::size_t array_length)
{
std::vector<std::pair<double, double>> array_xy;
array_xy.reserve(array_length);
std::generate_n(std::back_inserter(array_xy), array_length, [](){
return std::make_pair(rand()/static_cast<double>(RAND_MAX),
rand()/static_cast<double>(RAND_MAX));
});
std::vector<bool> bool_z;
bool_z.reserve(array_length);
auto bool_z_insterter = std::back_inserter(bool_z);
std::for_each(array_xy.cbegin(), array_xy.cend(), [&](const std::pair<double, double>& ref){
const auto func = [](const std::pair<double, double>& ref){
return sqrt(pow(ref.first, 2) + pow(ref.second, 2)) <= 1.0;
};
bool_z_insterter = func(ref);
});
const auto sum = 4.0 * (std::accumulate(bool_z.cbegin(), bool_z.cend(), 0.0)/array_length);
return sum;
}
int main(){
const auto concurrency_level = std::thread::hardware_concurrency();
std::vector< double > chunks_vector;
chunks_vector.reserve(chunks_number);
for (std::size_t j = 0; j < chunks_number; ++j) {
std::vector<std::future<double>> futures;
futures.reserve(concurrency_level-1);
for (std::size_t i = 0; i < concurrency_level-1; ++i){
auto f = std::async(std::launch::async, local_pi, array_size/concurrency_level);
futures.push_back(std::move(f));
}
auto pi = local_pi(array_size/concurrency_level);
for (auto&& x : futures ){
pi += x.get();
}
pi /= concurrency_level;
chunks_vector.push_back(pi);
}
const auto total_pi = std::accumulate(chunks_vector.cbegin(), chunks_vector.cend(), 0.0)/chunks_vector.size();
std::cout << "Pi equals = " << std::scientific << total_pi << std::endl;
return 0;
}