Parte I:

Python algoritmo 1:

import random

def monte_carlo_fixed(Nmax, a, b, f):

total = 0
for _ in range(Nmax):
x = random.uniform(a, b)
total += f(x)

integral = (b - a) * total / Nmax

return integral

Python algoritmo 2:

import random

def monte_carlo_tol(beta_tol, a, b, f):

integral = 0
N=0
beta = float('inf')

while beta > beta_tol:

x = random.uniform(a, b)
integral += f(x)
N += 1

mean = integral / N
var = sum([(f(random.uniform(a, b)) - mean) ** 2 for _ in range(N)]) / (N * (N - 1))
beta = var / mean ** 2

integral *= (b - a) / N
return integral

C++ algoritmo 1:

#include <iostream>
#include <random>
#include <functional>

double monte_carlo_fixed(int Nmax, double a, double b, std::function<double(double)> f) {

double total = 0;
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<double> dis(a, b);
 for (int i = 0; i < Nmax; ++i) {
double x = dis(gen);
total += f(x);
}

double integral = (b - a) * total / Nmax;

return integral;
}

C++ algoritmo 2:

#include <iostream>
#include <random>
#include <functional>

double monte_carlo_tol(double beta_tol, double a, double b, std::function<double(double)> f)

{
double integral = 0;
int N = 0;
double beta = std::numeric_limits<double>::infinity();
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<double> dis(a, b);

while (beta > beta_tol) {

double x = dis(gen);
integral += f(x);
N++;

double mean = integral / N;

double var = 0;
for (int i = 0; i < N; ++i) {
double xi = dis(gen);
var += (f(xi) - mean) * (f(xi) - mean);
}
var /= N * (N - 1);
beta = var / (mean * mean);
}

integral *= (b - a) / N;
return integral;
}
Resumo executivo:

Este trabalho apresenta duas implementações do algoritmo de Monte Carlo para

estimar a integral de uma função usando amostragem aleatória. Calcula a integral
de uma função com base na distribuição uniforme da variável x no intervalo [a, b].
Há duas versões do algoritmo: uma que usa um número fixo de amostras definido
pelo usuário, e outra que continua a gerar amostras até que o parâmetro Beta seja
inferior a uma tolerância Beta* também definida pelo usuário.

Implementei duas versões do algoritmo de Monte Carlo em Python e C++. A primeira

versão usa um número fixo de amostras definido pelo usuário para estimar a integral
de uma função, enquanto a segunda versão continua a gerar amostras até que o
parâmetro Beta seja inferior a uma tolerância definida pelo usuário.

É necessário considerar o equilíbrio entre a precisão desejada e o tempo de

execução necessário.

No geral, o algoritmo de Monte Carlo é uma abordagem para estimar integrais

usando amostragem aleatória e pode ser aplicado em várias áreas da ciência da
computação, especialmente quando a integração analítica não é viável ou precisa
ser evitada.
Parte II:

import random

def potencia(v):
return 0.05 * v**3

def potencia_media(Nmax):
a=7
b = 14
total = 0

for _ in range(Nmax):
v = random.uniform(a, b)
total += potencia(v)

potencia_media = total / Nmax

return potencia_media

Nmax = int(input("Digite o número de amostras Nmax: "))

potencia_media_estimada = potencia_media(Nmax)

print("Potência média estimada:", potencia_media_estimada)