Lab 5 Monte Carlo integration

Transcription

1 Lab 5 Monte Carlo integration Edvin Listo Zec edvinli@student.chalmers.se October 0, 014 Co-worker: Jessica Fredby

2 Introduction In this computer assignment we will discuss a technique for solving difficult, definite integrals called Monte Carlo integration. The method performs numerical integration with the use of random numbers. In this assignment we will try to estimate π using this method and we will also look at how the technique can be used to study the expected shortfall of a given scenario. Further, we will take a look at different variance reduction methods and try to minimise the variance when applying Monte Carlo integration. 1 Assignment 1 In this assignment we are going to calculate π with the integral, I(f) = x, numerically by using Monte Carlo integration. We re also going to perform an error estimate. Further, we re going to implement four different variance reduction techniques and calculate the integral using those. Assignment 1.1 Problem The task in this assignment is to use ordinary Monte Carlo integration to approximate the integral I(f) numerically. We should do this for several sample sizes n = 10 5, 10 6, 10 7,... We should further perform an error estimate, as if the true value of π is unknown and compare it to the actual error (calculated with the true value of π). Theory and implementation Monte Carlo is a non-deterministic technique used when one wants to calculate difficult integrals numerically. Monte Carlo integration uses random numbers to calculate the integral: it randomly chooses points at which the integrand is evaluated and is often used for higher-dimensional integrals. Consider the multidimensional integral x1=1 xn=1 I = f(x)dx =... f(x 1,..., x n )dx 1...dx n x 1=0 of a function f over the unit hypercube [0, 1] n = [0, 1]... [0, 1] in R n. This can be interpreted as the expectation E[f(X)] of the random variable f(x), which is an R n -valued random variable with uniform distribution over [0, 1] n. This means that X 1,..., X n are independent and identically uniform distributed over [0, 1] which is the same as X 1,..., X n being random numbers. The Monte Carlo approximation of I(f) is then: x n=0 S N = V 1 N N f(x i ) 1

3 where V is the volume of the integration region (in this case V = 1), N is the sample size and {x i } N are independent observations of X. It is the law of large numbers that guarantees that lim S N = I N Now when we have the approximation I from the sum, it is natural to calculate the error of S N. From the central limit theorem we get that the sample mean of a random variable with expected value µ and variance σ is approximately normally distributed N (µ, σ ). This means that the error can be estimated from using the Monte Carlo method on σ = (f(x) I(f)) dx: σ = (f(x) I(f))dx 1 N N (f(x i ) S N ) = 1 N N f(x i ) SN = ˆσ This gives us that Var[S N ] = V Now the estimation of the error of S N is N N Var[f(x i )] = V ˆσ N δs N Var[S N ] = V ˆσ N This means that the error decreases as 1 N, which does not depend on the number of dimensions of the integral. This is a big advantage of using Monte Carlo integration over many deterministic methods that depend exponentially on the dimension. However, the Monte Carlo method works for simple examples but not always in other cases. That is why we will look into four different ways of improving the error (importance sampling, control variates, antithetic variates and stratified sampling). We implemented this Monte Carlo integration in C by writing a function that takes the sample exponents as arguments (i.e. 6 and 8 if you want to sample from N = 10 6 to 10 8 ). This was done with two for loops: the outer loop that controls what sample size N we have and the inner loop that samples N random uniformly distributed numbers x i using drand48. For each number we calculate 4 the function value of 1+x at x i and add it to itself each inner loop. We also add up the error by squaring the function value. In the outer loop we divide the total value with N, as well as calculating the error by: 1 Error=sqrt(Errorterm/n pow(s_n,))/sqrt(n); We also calculate the actual error by looking at the difference between S N and C s own value of π using M_PI. Result and discussion The results are seen in table 1.1. As expected the approximation of π becomes more accurate each time we use a larger N, and naturally both the error and the actual error decreases. We see that the estimated error is almost the same as the actual error.

4 Table 1.1: The approximation S N using ordinary Monte Carlo approximation and the error for different N. N S N Error Actual error Assignment 1. Problem The task in this assignment is to re-calculate the integral by applying four different variance reduction techniques and checking if we get more accurate values of π, in other words see if the variances/errors get reduced. Theory and implementation We want to find estimators with small variance since the variance of S N is related to the performance of the estimators. A way to this is to implement variance reduction techniques, the idea being to transform the original observations by transformation that maintains the same expected value but reduces the variance of the estimator. We begin with a technique called importance sampling. The idea behind importance sampling is to choose a distribution that we ll simulate random variables from. The trick is to choose a distribution such that the density of the sampling points are close to the shape of the integrand, in other words we choose a distribution that over-weights the important region (hence the name importance sampling). Thus the uniform distribution is replaced by this other distribution. Let p(x) be a probability density function of the random variable X that only takes values in Ω. We have then that: I = Ω f(x)dx = Ω f(x) [ f(x) ] p(x) p(x)dx = E p p(x) As long as p(x) 0 for any x Ω for which f(x) 0. Here E p denotes the expectation with respect to the density p. Instead of using uniform distribution to generate random observations, we can use p, and thus approximating the integral I with S N = 1 N This Monte Carlo approximation yields the error σ before: ( f(x) ) ˆσ = 1 N p(x) N N f(x i ) p(x i ) ( f(x) p(x) ) / ( ) N, where σ f(x) p(x) ( f(xi ) ) S p(x i ) N is estimated as We note that if p is similar to f, the ratio f/p will be close to constant which implies that the variance will be small. 3

5 The importance sampling was implemented in C by using the density function p(x) = 1 3 (4 x) for x [0, 1] and zero elsewhere. Since p is non-negative and the integral from to equals 1 it is a density function. Also, it behaves similar to f(x) which is a desired trait, see figure 1.1. We calculated the approximation in the same fashion as in assignment 1.1, just that we now approximated the integral by calculating f and p at the uniformly distributed random number x i and adding f/p each loop. The random number x i comes from the inverse CDF: p(x) = 1 (4 x), 3 CDF = P (x) = p(x)dx = 1 3 (4 x) = 1 3 (4x x ), The inverse function becomes: x = ± 4 3y, P 1 (y) = 4 3y since x [0, 1] The error was calculated the same way as before. Figure 1.1: Plot of f(x) and a scaled version of the density function p(x). The second technique is control variates. This method is popular because it is effective at reducing the variance. The idea behind control variates is to introduce a new function g, called a control 4

6 variate. The thing about g is that it s similar to f and that the integral I(g) is known. By using the trick of adding and subtracting the same thing we get: I = f(x)dx = (f(x) g(x))dx + g(x)dx = (f(x) g(x))dx + I(g) Since f and g are similar the variance of f g should be smaller than variance of f. We then get the following approximation of I(f) by using ordinary Monte Carlo integration: S N = 1 N N (f(x i ) g(x i )) + I(g) Note that the variance now directly comes from the difference f g. Since f and g are similar also in this case, the variance of f g will be small as well. The method of control variates was implemented in C by choosing g(x) = 4 x for x [0, 1] and zero elsewhere. We see then than I(g) = 3 and we did the usual Monte Carlo integration on f(x) g(x). The third technique is called antithetic variates. This method relies on choosing pairs of observations (Y 1, Y ) such that their correlation is negative, which will reduce the variance. If we want to estimate θ =E[Y ] and have two generated samples Y 1, Y the unbiased estimate of θ is: And the variance is: ˆθ = ˆθ 1 + ˆθ Var[ˆθ] = Var[Y 1] + Var[Y ] + Cov[Y 1, Y ] 4 If Y 1, Y now are i.i.d. we get Var[Y 1 ] = Var[Y ] which gives Var[ˆθ] = Var[Y 1 ]/ = Var[Y ]/. Using the antithetic variates technique means that we choose the second sample so that Y 1, Y are not i.i.d. anymore and Cov[Y 1, Y ] is negative. This reduces the variance Var[ˆθ]. We implemented the antithetic variates method in C by using ordinary Monte Carlo integration, with the same implementaition as before, just this time on f(x i ) and on f(1 x i ): S N = 1 N N f(x i ) + 1 N N f(1 x i ) And thus the variance is implemented in the same way as before too: ˆσ = 1 N N ( f(xi ) + f(1 x ) i) S N The fourth and final technique we ll mention is the method if stratified sampling. The idea behind 5

7 this method is to divide the region of integration into smaller parts and using the usual Monte Carlo integration on each of the parts, using different sample sizes for different parts. This means that if we have our region of integration Ω = [0, 1] n we divide it into k regions Ω 1,...Ω k. A region Ω j has the volume V j and for each region we use the sample N j of the observations {x ij } Nj from a random variable X j. Here X j has a uniform distribution over Ω j and this leads to the Monte Carlo integration: The error of this approximation is S N = k V j N j N j=1 j j=1 f(x i,j ) SS = k Vj σj N (f) j where the variance σj from the region Ω j is: ( 1 ( 1 ) ) σj (f) = f(x) dx f(x)dx V j Ω j V j Ω j Here the variance σ j from Ω j is also calculated using Monte Carlo integration. We implemented this in C the same as before, but with a slight modification. We added a loop that looped from 1 to k where k is the number of parts we divided the integration region into. When we then sampled the uniformly distributed random number, we had to take into account that the integration region was divided into k different parts. We did this with the following line of code: 1 x_i=drand48()/(double)k + (double)(j 1)/(double)k; //all intervals are the same size, since we just divide the region by k Then we calculated f(x i ) the same as before, the difference being that we did it for each divided region. This means that V j = 1/k and that N j = N/k. However, one could choose N j V j σ j if one wants the stratified sampling to perform optimal. Result and discussion In tables 1., 1.3, 1.4, 1.5 we see the results after using the four different variance reduction methods. All methods seem to be effective since the error is smaller in all cases, meaning that the estimation of π is better than when using ordinary Monte Carlo approximation. With respect to the previous theory, this is what to be expected. The reason we get better results is that the four different variance reduction techniques transform our observations X = x 1,..., x n by different transformations, where the expectation E[X] is the same but the variance Var[X] is reduced. The final result being that each Monte Carlo simulation becomes more efficient. Table 1.: The approximation S N and the error for different N using importance sampling. N S N Error Actual error

8 Table 1.3: The approximation S N and the error for different N using control variates. N S N Error Actual error Table 1.4: The approximation S N and the error for different N using antithetic variates. N S N Error Actual error Table 1.5: The approximation S N and the error for different N using stratified sampling. N S n Error Actual error Assignment Assignment.1 Problem The task of this assignment is to compute estimations of I(f) = 1 f(x, y)dxy by the Monte Carlo 0 method, where f(x, y) = for all (x, y) [0, 1] and zero elsewhere. sin(xy) x 1 Theory and implementation We computed the integral using ordinary Monte Carlo integration as in assignment 1.1. The implementation in C is the same, the difference being the function and that we must generate two uniformly random numbers x i, y i, using drand48. Result and discussion We see in table.1 that the error is quite high and that the value of the Monte Carlo approximation differs quite a lot. This is most likely due to that the function f(x, y) has a singularity at x = 1, and every time we come close to this point when using Monte Carlo integration we get a large error. A plot of the function can be see in figure.1. To calculate this integral more correctly we would have to generate numbers in a way so we avoid the singularity, perhaps importance sampling could be used (but it will probably be hard to find a p that is similar to f)

9 Figure.1: Plot of f(x, y) = sin(xy) x 1. Table.1: The approximation S N f(x, y). and the error for different N using Monte Carlo integration on N S N Error Assignment 3 Assignment 3.1 Problem The task in this assignment is to study the expected shortfall E[S X (u)], which is a measure of the worst case scenario. We should use Monte Carlo integration to estimate the expected shortfall of a given scenario. 8

10 Theory and implementation The mathematical definition of the expected shortfall is the expectation of a loss random variable X, given that the loss is greater than a certain threshold u: E[S X (u)] = E[X X > u] The given scenario is that an insurance company has found that the probability of a flooding is p = 0.1. If a flood occurs, the loss is exponentially distributed with parameter λ = and mean 1 λ = 3.4. This could be simulated by having the loss X = Y Z where Y Bernoulli(p) and Z exp(λ), independent of Y. Also, we let u = 10. We circumvent the Bernoulli distribution by the fact that Y will be 1 with probability p = 0.1 and 0 with probability 1 p = 0.9, meaning that X = Z with a probability of p = 0.1 and zero otherwise. We thus get: E{Z Z > u} 1 N N f(x i ) = S N, where f(x i ) = { xi if x i > u 0 otherwise. The estimation of the error is calculated as before: δs N Var[S N ] = V The implementation in C was done by creating a function that takes λ and a random uniformly distributed number in [0, 1] as an argument, and then returning an exp(λ) distributed random number. This is done by inverse transform sampling. If we have a uniformly distributed random number x [0, 1], we get an exponentially distributed random number by taking the inverse of the cdf of the exponential distribution, i.e. F 1 (u) = ln(1 u) λ same goes for 1 u meaning we can use y = ln(u) λ ˆσ N. Since u is uniformly distributed on [0, 1], the to get an exponentially distributed random number. Now when we have an exp(λ) distributed random number, we make an if statement that only lets the random number z i pass if it is greater than 10 and if pr > p, where pr is a uniformly randomly generated number in the interval [0, 1] and p is the probability 0.1. In this if statement we then calculate the approximation S N with ordinary Monte Carlo approximation. The error term is also calculated the same way as usual. A little difference is that we in this if statement also count how many times we are in it with the variable m, and then divide S N with m instead of N (the same goes for the error). Result and discussion We see that for larger N the value converges towards 13.4, which is not that surprising since u = 10 and the mean of the exponentially distributed random variable is

11 Table 3.1: The approximation of the expected shortfall S N and the error for different N using ordinary Monte Carlo approximation. N S N Error Assignment 3. Problem The task in this assignment is to choose a variance reduction method and to recalculate the integral using it with the same sample size N. Theory and implementation We choose the antithetic variate method, due to the reason that our function is monotone and the technique can therefore be applied. For example, the exponentially distributed random variable X 1 = ln(u) λ with U uniformly distributed on [0, 1] and X = ln(1 U) λ will be negatively correlated, due to the fact that if U increases it implies that 1 U decreases and vice versa. More generally we can state that for any distribution F (x) with inverse F 1 (y) we can generate a negatively correlated pair: X 1 = F 1 (U), X = F 1 (1 U). This is because F 1 (y) is a monotone function, and the monotonicity preserves the negative correlation. Result and discussion Figure 3.1: Plot of F 1 (y) = ln(y) λ. The value still converges towards 13.4 when N gets large, which is expected. The antithetic variates technique does indeed reduce the variance, as seen in table 3., which is a result we are content with. 10

12 Table 3.: The approximation of the expected shortfall S N and the error for different N using antithetic variates. N S N Error

13 A Appendix A - Matlab code A.1 Assignment 1 1 // Assignment 1 #include <math.h> //for mathfunctions 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <time.h> // for timing 6 7 //Ordinary monte carlo 8 calcpi ( int start, int end){ 9 int n, ex; 10 double Errorterm, y, x_i, S_n, Error; 11 srand48(time(null)); 1 for(ex=start; ex<=end; ex=ex+1){ //loop over sample sizes between 10^start and 10^end 13 S_n=0; Errorterm=0; for (n=1; n<=pow(10,ex); n=n+1){ //loop over the sample size 16 x_i=drand48(); //generate random numbers from Uniform(0,1) 17 y=4/(1+(x_i) (x_i)); //calculate the function value 18 S_n=S_n+y; //sum the function values 19 Errorterm=Errorterm+y y; //estimate the sum in the error expression 0 } 1 S_n = S_n/n; //total S_n Error = sqrt(errorterm/n pow(s_n,))/sqrt(n); //total error 3 4 printf ("Power: %d\n", ex); 5 printf ("pi: %3.10f\n", S_n); 6 printf ("error : %3.10f\n", Error); 7 printf ("actual: %3.10f\n", M_PI S_n); 8 printf (" \n"); 9 } 30 } 31 3 //importance sampling 33 calcpi( int start, int end){ 34 int n, ex; 35 double y, x_i, S_n, var, p, u; 36 srand48(time(null)); 37 for(ex=start; ex<=end; ex=ex+1){ 38 S_n=0; var = 0; for (n=1; n<=pow(10,ex); n=n+1){ 41 u=drand48(); 4 x_i= sqrt(4 3 u); //random variable generated from the distribution with p s pdf 43 y=4/(1+(x_i) (x_i)); //function value 44 p=(4 x_i)/3; //pdf for the random variable 45 S_n=S_n+y/p; //sum the function values 46 var=var + pow(y/p,); // sum in variance expression 47 } 48 S_n = S_n/n; //total S_n 49 var=var/n pow(s_n,); //total variance printf ("Power: %d\n", ex); 5 printf ("pi: %3.10f\n", S_n);

14 53 printf ("error : %3.10f\n", sqrt(var/n)); //estiamte error 54 printf ("actual: %3.10f\n", M_PI S_n); 55 printf (" \n"); 56 } } //control variates 61 calcpi3( int start, int end){ 6 int n, ex; 63 double y, x_i, S_n, var, g; 64 int I_g=3; 65 srand48(time(null)); 66 for(ex=start; ex<=end; ex=ex+1){ 67 S_n=0; var = 0; for (n=1; n<=pow(10,ex); n=n+1){ 70 x_i=drand48(); 71 y=4/(1+(x_i) (x_i)); //function value 7 g=(4 x_i); //the value of the other function g 73 S_n=S_n+y g; //sum the function values 74 var= var + pow(y g+i_g,); // sum in variance expression 75 } 76 S_n = S_n/n + I_g; //total S_n 77 var=var/n pow(s_n,); //total variance printf ("Power: %d\n", ex); 80 printf ("pi: %3.10f\n", S_n); 81 printf ("error : %3.10f\n", sqrt(var/n)); //estiamte error 8 printf ("actual: %3.10f\n", M_PI S_n); 83 printf (" \n"); 84 } 85 } // antithetic variates 88 calcpi4( int start, int end){ 89 int n; int ex; 90 double y, y, x_i, S_n, S_n, var; 91 srand48(time(null)); 9 for(ex=start; ex<=end; ex=ex+1){ 93 S_n=0; S_n=0; 94 var = 0; 95 for (n=1; n<=pow(10,ex); n=n+1){ 96 x_i=drand48(); 97 y=4/(1+(x_i) (x_i)); //function value for f(x) 98 y=4/(1+(1 x_i) (1 x_i)); //function value value for f(1 x) 99 S_n=S_n+y/; //sum over f(x) 100 S_n=S_n+y/; //sum over f(1 x) 101 var= var + pow(y/+y/,); //sum in variance expression 10 } 103 S_n = S_n/n + S_n/n; //total S_n 104 var=var/n pow(s_n,); //total variance printf ("Power: %d\n", ex); 107 printf ("pi: %3.10f\n", S_n); 108 printf ("error : %3.10f\n", sqrt(var/n)); //estiamte error 109 printf ("actual: %3.10f\n", M_PI S_n);

15 110 printf (" \n"); 111 } 11 } // stratified sampling 115 calcpi5( int start, int end){ 116 int n, j, ex, M=1; 117 double y, x_i, S_n, S_tot, var, M_j, n_j; 118 int k=4; //number of domains 119 double error, sum1, sum, sigma; 10 srand48(time(null)); 11 for(ex=start; ex<=end; ex=ex+1){ //loop over sample sizes between 10^start and 10^end 1 S_tot=0; 13 var = 0; error=0; 14 M_j=(double)M/(double)k; //length of the domain 15 n_j=pow(10,ex)/(double)k; //sample size in each domain 16 for( j=1; j<=k; j=j+1){ //loop over all domains 17 S_n=0; sum1=0; sum=0; sigma=0; 18 for (n=1; n<=n_j; n=n+1){ //loop over the sample size for each domain 19 x_i=drand48()/(double)k + (double)(j 1)/(double)k; //generate random numbers of uniformly distr. from domain M_j. 130 y=4/(1+(x_i) (x_i)); //the function value 131 S_n=S_n+y; 13 sum1=sum1+pow(y,); //first sum in variance expression 133 sum=s_n; //second sum in variance expression 134 } 135 S_tot=S_tot+M_j (S_n/n_j); //total S_n 136 sum1=sum1/(n_j); 137 sum=sum/(n_j); 138 sigma=(sum1 pow(sum, )); //calculate variance 139 error=error+pow(m_j,) (sigma/n_j); //calculate error 140 } 141 error=sqrt(error); printf ("Power: %d \n", ex); 144 printf ("pi: %3.10f\n", S_tot); 145 printf ("error : %3.10f\n", error); 146 printf ("actual: %3.10f\n", M_PI S_tot); 147 printf (" \n"); 148 } } main(){ 153 // Conduct Monte Carlo simulations 154 printf (" Ordinary Monte Carlo \n"); 155 calcpi (4,8) ; 156 printf (" Importance sampling \n"); 157 calcpi (4,8) ; 158 printf (" Control variates \n"); 159 calcpi3 (4,8) ; 160 printf (" Antithetic variates \n"); 161 calcpi4 (4,8) ; 16 printf (" Stratified sampling \n"); 163 calcpi5 (4,8) ; 164 return 0; 165

16 166 } A. Assignment 1 //Assignment #include <math.h> //for mathfunctions 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <time.h> // for timing 6 7 montcarl(int start, int end){ 8 int n; int ex; 9 double Errorterm, f, y_i, x_i, S_n, Error; srand48(time(null)); 1 for(ex=start; ex<=end; ex=ex+1){ //loop over sample sizes between 10^start and 10^end 13 S_n=0; Errorterm=0; for (n=1; n<=pow(10,ex); n=n+1){ //loop over the sample size 16 x_i=drand48(); 17 y_i=drand48(); 18 f=fabs(sin(x_i y_i)/(x_i 0.5)); //calculate the function value 19 S_n=S_n+f; //sum the function values 0 Errorterm=Errorterm+pow(f,); //sum in error expression 1 } S_n = S_n/n; //final S_n 3 Error=sqrt(Errorterm/n S_n S_n)/sqrt(n); //total estiamted error 4 5 printf ("Power: %d\n", ex); 6 printf ("function: %f\n", S_n); 7 printf ("error : %f\n", Error); 8 printf (" \n"); 9 } 30 } 31 3 main(){ 33 montcarl(4,8); 34 return 0; 35 } A.3 Assignment 3 1 //Assignment 3 3 #include <math.h> //for mathfunctions 4 #include <stdio.h> 5 #include <stdlib.h> 6 #include <time.h> // for timing 7 8 double normrnd(double mu,double sigma){ 9 double chi,eta; 10 chi=drand48();

17 11 eta=drand48(); 1 //M_PI is a constant in math.h 13 return mu+sigma sqrt( log(chi)) cos( M_PI eta);; 14 } double exprnd(double lambda){ 17 double u; 18 u = drand48(); 19 return ( log(u)/lambda); 0 } 1 double exprnd(double lambda, double u){ 3 4 return ( log(u)/lambda); 5 } expshort(int start, int end){ 9 int n; int ex; int m; 30 double Errorterm, z_i, f1, f, S_n, S_n1, S_n, S_tot, Error, pr; 31 double lambda = 1/3.4; double p=0.1; 3 srand48(time(null)); 33 for(ex=start; ex<=end; ex=ex+1){ 34 Errorterm=0;m=0;S_n=0; 35 for (n=1; n<=pow(10,ex); n++){ 36 z_i=exprnd(lambda); 37 //printf("z: %f\n:", z_i); 38 pr=drand48(); 39 if (pr>=p && z_i>10){ 40 //f=lambda exp( lambda z_i); 41 //f1 = z_i lambda exp( lambda z_i); 4 //printf("f : %f\n", f); 43 S_n += z_i; 44 //S_n1 = S_n1+f1; //should it be 1 f here? 45 //S_n = S_n+f; 46 //printf("sn1: %f\n", S_n1); 47 //printf("sn: %f\n", S_n); 48 Errorterm += z_i z_i; 49 m++; //this is our true sample size 50 } 51 } 5 S_n = S_n/m; 53 //S_n1 = S_n1/(0.9 n); 54 //S_n = S_n/(n); 55 //S_tot = S_tot + S_n1/S_n; printf ("Power: %d\n", ex); 58 Error = sqrt(errorterm/m pow(s_n,))/sqrt(m); 59 printf ("Exp.sh.: %f\n", S_n); 60 printf ("error : %f\n", Error); 61 printf (" \n"); 6 } 63 } // antithetic 66 anti( int start, int end){ 67 int n; int ex; double m, m;

18 68 double Errorterm, z_i, f1, f, S_n, S_n1, S_n, S_tot, Error, pr, d, z_i, var, y, y, m3; 69 double lambda = 1/3.4; double p=0.1; 70 srand48(time(null)); 71 for(ex=start; ex<=end; ex=ex+1){ 7 Errorterm=0;m=0;S_n1=0;S_n=0; 73 S_tot=0; m=0; m3=0; var = 0; for (n=1; n<=pow(10,ex); n++){ 76 pr=drand48(); 77 d=drand48(); 78 z_i=exprnd(lambda, d); 79 z_i=exprnd(lambda, 1 d); y=0; y=0; 8 //printf("z: %f\n:", z_i); if (pr>=p && z_i>10){ 85 S_n1 += z_i/; 86 y = z_i/; 87 m++; //this is our true sample size 88 } 89 if (pr>=p && z_i>10){ 90 S_n += z_i/; 91 y = z_i/; 9 m++; 93 } 94 var += pow(z_i/+z_i/,); } 97 S_n1 = S_n1/m; 98 S_n = S_n/m; 99 S_tot = S_n1 + S_n; 100 var=var/((m+m)/) pow(s_tot,); //what should n be here??? 101 printf ("Power: %d\n", ex); 10 printf ("Exp.sh.: %f\n", S_tot); 103 printf ("error : %3.10f\n", sqrt(var/((m+m)/))); 104 printf (" \n"); 105 } 106 } main(){ 111 //expshort(4,8); 11 anti (4,8) ; 113 return 0; 114 } / 118 ass1 119 regarding importance sampling: how do we replace the uniform distribution with p(x) distribution? or is it also uniform since x is in [0,1]? ass3 1 where should we multiply with 0.1? 13 should we have f or 1 f

19 14 15 general 16 about n=10^6, why is this one worse? 17 /