Probability Fundamentals

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
// Compute exact probability by enumerating all 36 outcomes
5
double exact_prob_sum_eq_7() {
6
    int favorable = 0;
7
    int total = 0;
8
    for (int d1 = 1; d1 <= 6; ++d1) {
9
        for (int d2 = 1; d2 <= 6; ++d2) {
10
            ++total;
11
            if (d1 + d2 == 7) ++favorable;
12
        }
13
    }
14
    return static_cast<double>(favorable) / total; // |A| / |Ω|
15
}
16
17
// Estimate probability via Monte Carlo simulation
18
// N = number of trials; uses C++11 <random>
19
double monte_carlo_prob_sum_eq_7(long long N, unsigned seed = std::random_device{}()) {
20
    mt19937 rng(seed);
21
    uniform_int_distribution<int> die(1, 6);
22
    long long hits = 0;
23
    for (long long t = 0; t < N; ++t) {
24
        int d1 = die(rng);
25
        int d2 = die(rng);
26
        if (d1 + d2 == 7) ++hits; // indicator I_{sum=7}
27
    }
28
    return static_cast<double>(hits) / static_cast<double>(N);
29
}
30
31
int main() {
32
    cout.setf(std::ios::fixed); cout << setprecision(6);
33
    double exact = exact_prob_sum_eq_7();
34
    cout << "Exact P(sum=7) = " << exact << "\n";
35
36
    // Try a few Monte Carlo sizes to see convergence ~ 1/sqrt(N)
37
    for (long long N : {1000LL, 10000LL, 100000LL}) {
38
        double est = monte_carlo_prob_sum_eq_7(N);
39
        cout << "Monte Carlo N=" << N << ": " << est << " (error " << fabs(est - exact) << ")\n";
40
    }
41
    return 0;
42
}
43

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
struct Card {
5
    int rank;   // 1=Ace, 2..10, 11=Jack, 12=Queen, 13=King
6
    int suit;   // 0=Hearts, 1=Diamonds, 2=Clubs, 3=Spades
7
};
8
9
vector<Card> make_deck() {
10
    vector<Card> deck;
11
    deck.reserve(52);
12
    for (int s = 0; s < 4; ++s) {
13
        for (int r = 1; r <= 13; ++r) deck.push_back({r, s});
14
    }
15
    return deck;
16
}
17
18
bool is_red(const Card& c) { return c.suit == 0 || c.suit == 1; }
19
bool is_ace(const Card& c) { return c.rank == 1; }
20
21
// Exact conditional probability P(A|B) = P(A ∩ B) / P(B) via counting
22
pair<double,double> exact_conditional_ace_given_red() {
23
    auto deck = make_deck();
24
    int countB = 0, countAB = 0;
25
    for (const auto& c : deck) {
26
        if (is_red(c)) {
27
            ++countB; // in B
28
            if (is_ace(c)) ++countAB; // in A ∩ B
29
        }
30
    }
31
    double pB = static_cast<double>(countB) / deck.size();
32
    double pAB = static_cast<double>(countAB) / deck.size();
33
    double pAgivenB = (pB > 0 ? pAB / pB : numeric_limits<double>::quiet_NaN());
34
    return {pAgivenB, pB};
35
}
36
37
// Monte Carlo estimate of P(A|B) by rejection sampling (filter on B)
38
double mc_conditional_ace_given_red(long long N, unsigned seed = std::random_device{}()) {
39
    auto deck = make_deck();
40
    mt19937 rng(seed);
41
    uniform_int_distribution<int> pick(0, (int)deck.size() - 1);
42
43
    long long countB = 0, countAB = 0;
44
    for (long long t = 0; t < N; ++t) {
45
        const Card& c = deck[pick(rng)];
46
        if (is_red(c)) {
47
            ++countB;
48
            if (is_ace(c)) ++countAB;
49
        }
50
    }
51
    return (countB > 0 ? (double)countAB / (double)countB : numeric_limits<double>::quiet_NaN());
52
}
53
54
int main() {
55
    cout.setf(std::ios::fixed); cout << setprecision(6);
56
    auto [exact, pB] = exact_conditional_ace_given_red();
57
    cout << "P(ace | red) exact = " << exact << ", P(red) = " << pB << "\n";
58
59
    // Try Monte Carlo
60
    for (long long N : {1000LL, 10000LL, 100000LL}) {
61
        double est = mc_conditional_ace_given_red(N);
62
        cout << "MC N=" << N << ": P(ace|red) ≈ " << est << "\n";
63
    }
64
    return 0;
65
}
66

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
struct ProbTriplet { double pA, pB, pAB; };
5
6
// Enumerate Ω = {1..6} × {1..6} to compute P(A), P(B), P(A ∩ B)
7
ProbTriplet enumerate_events(function<bool(int,int)> A, function<bool(int,int)> B) {
8
    int total = 0, a = 0, b = 0, ab = 0;
9
    for (int d1 = 1; d1 <= 6; ++d1) {
10
        for (int d2 = 1; d2 <= 6; ++d2) {
11
            ++total;
12
            bool inA = A(d1, d2);
13
            bool inB = B(d1, d2);
14
            if (inA) ++a;
15
            if (inB) ++b;
16
            if (inA && inB) ++ab;
17
        }
18
    }
19
    return {a/(double)total, b/(double)total, ab/(double)total};
20
}
21
22
bool approx_equal(double x, double y, double eps=1e-12) {
23
    return fabs(x - y) <= eps * max(1.0, max(fabs(x), fabs(y)));
24
}
25
26
int main() {
27
    cout.setf(std::ios::fixed); cout << setprecision(6);
28
29
    // Example 1: A = {first die even}, B = {sum equals 7} (independent)
30
    auto A1 = [](int d1, int d2){ (void)d2; return d1 % 2 == 0; };
31
    auto B1 = [](int d1, int d2){ return d1 + d2 == 7; };
32
    auto t1 = enumerate_events(A1, B1);
33
    cout << "Example 1:\n";
34
    cout << "P(A)=" << t1.pA << ", P(B)=" << t1.pB << ", P(A∩B)=" << t1.pAB
35
         << ", P(A)P(B)=" << t1.pA * t1.pB << "\n";
36
    cout << "Independent? " << (approx_equal(t1.pAB, t1.pA * t1.pB) ? "Yes" : "No") << "\n\n";
37
38
    // Example 2: A = {first die even}, C = {sum ≥ 10} (dependent)
39
    auto A2 = [](int d1, int d2){ (void)d2; return d1 % 2 == 0; };
40
    auto C2 = [](int d1, int d2){ return d1 + d2 >= 10; };
41
    auto t2 = enumerate_events(A2, C2);
42
    cout << "Example 2:\n";
43
    cout << "P(A)=" << t2.pA << ", P(C)=" << t2.pB << ", P(A∩C)=" << t2.pAB
44
         << ", P(A)P(C)=" << t2.pA * t2.pB << "\n";
45
    cout << "Independent? " << (approx_equal(t2.pAB, t2.pA * t2.pB) ? "Yes" : "No") << "\n";
46
47
    return 0;
48
}
49

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
struct TestParams { double prevalence; double sensitivity; double specificity; };
5
6
// Compute posterior probabilities given a binary diagnostic test
7
// PPV = P(Disease | Test+), NPV = P(No Disease | Test-)
8
pair<double,double> bayes_binary(const TestParams& p) {
9
    double prev = p.prevalence;
10
    double se = p.sensitivity;   // P(+ | D)
11
    double sp = p.specificity;   // P(- | ~D)
12
13
    // P(+)=P(+|D)P(D) + P(+|~D)P(~D) = se*prev + (1-sp)*(1-prev)
14
    double p_pos = se*prev + (1.0 - sp)*(1.0 - prev);
15
    double p_neg = 1.0 - p_pos; // or sp*(1-prev) + (1-se)*prev
16
17
    double ppv = (p_pos > 0 ? (se*prev)/p_pos : numeric_limits<double>::quiet_NaN());
18
    double npv = (p_neg > 0 ? (sp*(1.0 - prev))/p_neg : numeric_limits<double>::quiet_NaN());
19
    return {ppv, npv};
20
}
21
22
int main() {
23
    cout.setf(std::ios::fixed); cout << setprecision(6);
24
    // Example: prevalence 1%, sensitivity 99%, specificity 95%
25
    TestParams p{0.01, 0.99, 0.95};
26
    auto [ppv, npv] = bayes_binary(p);
27
    cout << "Prevalence= " << p.prevalence << ", Sensitivity= " << p.sensitivity
28
         << ", Specificity= " << p.specificity << "\n";
29
    cout << "PPV = P(Disease | +) = " << ppv << "\n";
30
    cout << "NPV = P(No Disease | -) = " << npv << "\n";
31
    return 0;
32
}
33