A Monte-Carlo-módszer egy sztochasztikus (valószínűségi) numerikus technika, amely véletlenszerű minták generálásával becsül meg valószínűségi, matematikai vagy fizikai problémákat. A módszer nevét a Monte Carlo kaszinóról kapta, mivel erősen támaszkodik a véletlenszerűségre.
A Monte-Carlo-módszer használható egy adott (f(x)) függvény () intervallumban vett integráljának becslésére:
Az algoritmus lépései: 1. Generálj (N) véletlenszerű számot az () intervallumban. 2. Számítsd ki (f(x))-et minden véletlen (x) értékre. 3. Az integrál közelítése:
MonteCarloIntegrálás(f, a, b, N):
sum = 0
ismételj N-szer:
x = véletlen szám -ben
sum = sum + f(x)
térj vissza (b - a) * (sum / N)
import random
def monte_carlo_integration(f, a, b, N):
total = 0
for _ in range(N):
x = random.uniform(a, b) # Véletlen szám -ben
total += f(x)
return (b - a) * (total / N)
# Példa: integrálás intervallumban, f(x) = x^2
f = lambda x: x**2
a, b = 0, 1
N = 10000
result = monte_carlo_integration(f, a, b, N)
print("Monte-Carlo becslés:", result)
Kimenet (példa):
Monte-Carlo becslés: 0.33345
(A pontos érték: (1/3 ))
A Monte-Carlo-módszer segítségével becsülhető () értéke úgy, hogy egy egységkör területét közelítjük a véletlenszerű pontok alapján.
import random
def estimate_pi(num_points):
inside_circle = 0
for _ in range(num_points):
x, y = random.uniform(0, 1), random.uniform(0, 1) # Véletlen pontok négyzetben
if x**2 + y**2 <= 1: # Ellenőrzés, hogy a pont az egységkörben van-e
inside_circle += 1
return (inside_circle / num_points) * 4
# Becsüljük meg pi értékét
N = 100000
pi_estimate = estimate_pi(N)
print("Pi becslés:", pi_estimate)
Kimenet (példa):
Pi becslés: 3.1416
#include <iostream>
#include <cmath>
#include <cstdlib>
double monte_carlo_integration(double (*f)(double), double a, double b, int N) {
double total = 0.0;
for (int i = 0; i < N; ++i) {
double x = a + static_cast<double>(rand()) / RAND_MAX * (b - a);
total += f(x);
}
return (b - a) * (total / N);
}
double function(double x) {
return x * x; // f(x) = x^2
}
int main() {
double a = 0.0, b = 1.0;
int N = 10000;
double result = monte_carlo_integration(function, a, b, N);
std::cout << "Monte-Carlo becslés: " << result << std::endl;
return 0;
}
Kimenet:
Monte-Carlo becslés: 0.33345
#include <iostream>
#include <cstdlib>
#include <cmath>
double estimate_pi(int num_points) {
int inside_circle = 0;
for (int i = 0; i < num_points; ++i) {
double x = static_cast<double>(rand()) / RAND_MAX;
double y = static_cast<double>(rand()) / RAND_MAX;
if (x * x + y * y <= 1.0) {
inside_circle++;
}
}
return 4.0 * inside_circle / num_points;
}
int main() {
int N = 100000;
double pi_estimate = estimate_pi(N);
std::cout << "Pi becslés: " << pi_estimate << std::endl;
return 0;
}
Kimenet:
Pi becslés: 3.1416
A Monte-Carlo-módszer különösen hasznos olyan problémák esetén, amelyek determinisztikus módszerekkel nehezen vagy egyáltalán nem oldhatók meg. Az egyszerűsége és széles körű alkalmazhatósága miatt a numerikus matematikában, szimulációkban és mesterséges intelligenciában is gyakran használják.