TheAlgorithms-C-Plus-Plus/math/approximate_pi.cpp

/**
 * @file
 * @brief
 * Implementation to calculate an estimate of the [number π
 * (Pi)](https://en.wikipedia.org/wiki/File:Pi_30K.gif).
 *
 * @details
 * We take a random point P with coordinates (x, y) such that 0 ≤ x ≤ 1 and 0 ≤
 * y ≤ 1. If x² + y² ≤ 1, then the point is inside the quarter disk of radius 1,
 * else the point is outside. We know that the probability of the point being
 * inside the quarter disk is equal to π/4 double approx(vector<Point> &pts)
 * which will use the points pts (drawn at random) to return an estimate of the
 * number π
 * @note This implementation is better than naive recursive or iterative
 * approach.
 *
 * @author [Qannaf AL-SAHMI](https://github.com/Qannaf)
 */

#include <cassert>   /// for assert
#include <cstdlib>   /// for std::rand
#include <iostream>  /// for IO operations
#include <vector>    /// for std::vector

/**
 * @namespace math
 * @brief Mathematical algorithms
 */
namespace math {

/**
 * @brief structure of points containing two numbers, x and y, such that 0 ≤ x ≤
 * 1 and 0 ≤ y ≤ 1.
 */
using Point = struct {
    double x;
    double y;
};

/**
 * @brief This function uses the points in a given vector 'pts' (drawn at
 * random) to return an approximation of the number π.
 * @param pts Each item of pts contains a point. A point is represented by the
 * point structure (coded above).
 * @return  an estimate of the number π.
 */
double approximate_pi(const std::vector<Point> &pts) {
    double count = 0;  // Points in circle
    for (Point p : pts) {
        if ((p.x * p.x) + (p.y * p.y) <= 1) {
            count++;
        }
    }
    return 4.0 * count / static_cast<double>(pts.size());
}
}  // namespace math

/**
 * @brief Self-test implementations
 * @returns void
 */
static void tests() {
    std::vector<math::Point> rands;
    for (std::size_t i = 0; i < 100000; i++) {
        math::Point p;
        p.x = rand() / static_cast<double>(RAND_MAX);  // 0 <= x <= 1
        p.y = rand() / static_cast<double>(RAND_MAX);  // 0 <= y <= 1
        rands.push_back(p);
    }
    assert(math::approximate_pi(rands) > 3.135);
    assert(math::approximate_pi(rands) < 3.145);

    std::cout << "All tests have successfully passed!" << std::endl;
}

/**
 * @brief Main function
 * @returns 0 on exit
 */
int main() {
    tests();  // run self-test implementations
    return 0;
}