# 3.4: Numerical Approximation of Multiple Integrals - Mathematics

As you have seen, calculating multiple integrals is tricky even for simple functions and regions. For complicated functions, it may not be possible to evaluate one of the iterated integrals in a simple closed form. Luckily there are numerical methods for approximating the value of a multiple integral. The method we will discuss is called the Monte Carlo method. The idea behind it is based on the concept of the average value of a function, which you learned in single-variable calculus. Recall that for a continuous function (f (x)), the average value (ar f ext{ of }f) over an interval ([a,b]) is defined as

[ar f = dfrac{1}{b-a}int_a^b f (x),dx label{Eq3.11}]

The quantity (b − a) is the length of the interval ([a,b]), which can be thought of as the “volume” of the interval. Applying the same reasoning to functions of two or three variables, we define the average value of (f (x, y)) over a region (R) to be

[ar f = dfrac{1}{A(R)} iintlimits_R f (x, y),d A label{Eq3.12}]

where (A(R)) is the area of the region (R), and we define the average value of (f (x, y, z)) over a solid (S) to be

[ar f = dfrac{1}{V(S)} iiintlimits_S f (x, y, z),dV label{Eq3.13}]

where (V(S)) is the volume of the solid (S). Thus, for example, we have

[iintlimits_R f (x, y),d A = A(R) ar f label{Eq3.14}]

The average value of (f (x, y)) over (R) can be thought of as representing the sum of all the values of (f) divided by the number of points in (R). Unfortunately there are an infinite number (in fact, uncountably many) points in any region, i.e. they can not be listed in a discrete sequence. But what if we took a very large number (N) of random points in the region (R) (which can be generated by a computer) and then took the average of the values of (f) for those points, and used that average as the value of (ar f) ? This is exactly what the Monte Carlo method does. So in Formula ef{Eq3.14} the approximation we get is

[iintlimits_R f (x, y),d A approx A(R) ar f pm A(R) sqrt{dfrac{ar {f^2}-(ar f)^2}{N}}label{Eq3.15}]

where

[ar f = dfrac{sum_{i=1}^{N}f(x_i,y_i)}{N} ext{ and } ar {f^2} = dfrac{sum_{i=1}^{N}(f(x_i,y_i))^2}{N}label{Eq3.16}]

with the sums taken over the (N) random points ((x_1 , y_1), ..., (x_N , y_N )). The (pm) “error term” in Formula ef{Eq3.15} does not really provide hard bounds on the approximation. It represents a single standard deviation from the expected value of the integral. That is, it provides a likely bound on the error. Due to its use of random points, the Monte Carlo method is an example of a probabilistic method (as opposed to deterministic methods such as Newton’s method, which use a specific formula for generating points).

For example, we can use Formula ef{Eq3.15} to approximate the volume (V) under the plane (z = 8x + 6y) over the rectangle (R = [0,1] imes [0,2]). In Example 3.1 in Section 3.1, we showed that the actual volume is 20. Below is a code listing (montecarlo.java) for a Java program that calculates the volume, using a number of points (N) that is passed on the command line as a parameter. Listing 3.1 Program listing for montecarlo.java

The results of running this program with various numbers of random points (e.g. java montecarlo 100) are shown below: As you can see, the approximation is fairly good. As (N o infty), it can be shown that the Monte Carlo approximation converges to the actual volume (on the order of (O( sqrt{N})), in computational complexity terminology).

In the above example the region (R) was a rectangle. To use the Monte Carlo method for a nonrectangular (bounded) region (R), only a slight modification is needed. Pick a rectangle ( ilde R ext{ that encloses }R), and generate random points in that rectangle as before. Then use those points in the calculation of (ar f) only if they are inside (R). There is no need to calculate the area of (R) for Equation ef{Eq3.15} in this case, since the exclusion of points not inside (R) allows you to use the area of the rectangle ( ilde R) instead, similar to before.

For instance, in Example 3.4 we showed that the volume under the surface (z = 8x + 6y) over the nonrectangular region (R = {(x, y) : 0 ≤ x ≤ 1, 0 ≤ y ≤ 2x^2 }) is 6.4. Since the rectangle ( ilde R = [0,1] imes [0,2] ext{ contains }R), we can use the same program as before, with the only change being a check to see if (y < 2x^2) for a random point ((x, y) ext{ in }[0,1] imes [0,2]). Listing 3.2 below contains the code (montecarlo2.java):  Listing 3.2 Program listing for montecarlo2.java

The results of running the program with various numbers of random points (e.g. java montecarlo2 1000) are shown below: To use the Monte Carlo method to evaluate triple integrals, you will need to generate random triples ((x, y, z)) in a parallelepiped, instead of random pairs ((x, y)) in a rectangle, and use the volume of the parallelepiped instead of the area of a rectangle in Equation ef{Eq3.15} (see Exercise 2). For a more detailed discussion of numerical integration methods, see PRESS et al.

## 3.4: Numerical Approximation of Multiple Integrals - Mathematics

In this chapter we’ve spent quite a bit of time on computing the values of integrals. However, not all integrals can be computed. A perfect example is the following definite integral.

We now need to talk a little bit about estimating values of definite integrals. We will look at three different methods, although one should already be familiar to you from your Calculus I days. We will develop all three methods for estimating

by thinking of the integral as an area problem and using known shapes to estimate the area under the curve.

Let’s get first develop the methods and then we’ll try to estimate the integral shown above.

#### Midpoint Rule

This is the rule that should be somewhat familiar to you. We will divide the interval (left[ ight]) into (n) subintervals of equal width,

We will denote each of the intervals as follows,

Then for each interval let (x_i^*) be the midpoint of the interval. We then sketch in rectangles for each subinterval with a height of (fleft( ight)). Here is a graph showing the set up using (n = 6). We can easily find the area for each of these rectangles and so for a general (n) we get that,

Or, upon factoring out a (Delta x) we get the general Midpoint Rule.

#### Trapezoid Rule

For this rule we will do the same set up as for the Midpoint Rule. We will break up the interval (left[ ight]) into (n) subintervals of width,

Then on each subinterval we will approximate the function with a straight line that is equal to the function values at either endpoint of the interval. Here is a sketch of this case for (n = 6). Each of these objects is a trapezoid (hence the rule’s name…) and as we can see some of them do a very good job of approximating the actual area under the curve and others don’t do such a good job.

The area of the trapezoid in the interval (left[ <<>>,> ight]) is given by,

So, if we use (n) subintervals the integral is approximately,

Upon doing a little simplification we arrive at the general Trapezoid Rule.

Note that all the function evaluations, with the exception of the first and last, are multiplied by 2.

#### Simpson’s Rule

This is the final method we’re going to take a look at and in this case we will again divide up the interval (left[ ight]) into (n) subintervals. However, unlike the previous two methods we need to require that (n) be even. The reason for this will be evident in a bit. The width of each subinterval is,

In the Trapezoid Rule we approximated the curve with a straight line. For Simpson’s Rule we are going to approximate the function with a quadratic and we’re going to require that the quadratic agree with three of the points from our subintervals. Below is a sketch of this using (n = 6). Each of the approximations is colored differently so we can see how they actually work. Notice that each approximation actually covers two of the subintervals. This is the reason for requiring (n) to be even. Some of the approximations look more like a line than a quadratic, but they really are quadratics. Also note that some of the approximations do a better job than others. It can be shown that the area under the approximation on the intervals (left[ <<>>,> ight]) and (left[ <,<>>> ight]) is,

If we use (n) subintervals the integral is then approximately,

Upon simplifying we arrive at the general Simpson’s Rule.

In this case notice that all the function evaluations at points with odd subscripts are multiplied by 4 and all the function evaluations at points with even subscripts (except for the first and last) are multiplied by 2. If you can remember this, this is a fairly easy rule to remember.

Okay, it’s time to work an example and see how these rules work.

First, for reference purposes, Mathematica gives the following value for this integral.

In each case the width of the subintervals will be,

and so the subintervals will be,

Let’s go through each of the methods.

Remember that we evaluate at the midpoints of each of the subintervals here! The Midpoint Rule has an error of 1.96701523.

The Trapezoid Rule has an error of 4.19193129

The Simpson’s Rule has an error of 0.90099869.

None of the estimations in the previous example are all that good. The best approximation in this case is from the Simpson’s Rule and yet it still had an error of almost 1. To get a better estimation we would need to use a larger (n). So, for completeness sake here are the estimates for some larger value of (n).

 Midpoint Trapezoid Simpson’s (n) Approx. Error Approx. Error Approx. Error 8 15.9056767 0.5469511 17.5650858 1.1124580 16.5385947 0.0859669 16 16.3118539 0.1407739 16.7353812 0.2827535 16.4588131 0.0061853 32 16.4171709 0.0354568 16.5236176 0.0709898 16.4530297 0.0004019 64 16.4437469 0.0088809 16.4703942 0.0177665 16.4526531 0.0000254 128 16.4504065 0.0022212 16.4570706 0.0044428 16.4526294 0.0000016

In this case we were able to determine the error for each estimate because we could get our hands on the exact value. Often this won’t be the case and so we’d next like to look at error bounds for each estimate.

These bounds will give the largest possible error in the estimate, but it should also be pointed out that the actual error may be significantly smaller than the bound. The bound is only there so we can say that we know the actual error will be less than the bound.

So, suppose that (left| ight| le K) and (left| <>left( x ight)> ight| le M) for (a le x le b) then if (), (), and () are the actual errors for the Midpoint, Trapezoid and Simpson’s Rule we have the following bounds,

We already know that (n = 4), (a = 0), and (b = 2) so we just need to compute (K) (the largest value of the second derivative) and (M) (the largest value of the fourth derivative). This means that we’ll need the second and fourth derivative of (fleft( x ight)).

Here is a graph of the second derivative. Here is a graph of the fourth derivative. So, from these graphs it’s clear that the largest value of both of these are at (x = 2). So,

[eginf''left( 2 ight) & = 982.7667hspace<0.25in>hspace <0.25in>Rightarrow hspace<0.25in>hspace<0.25in>K = 983 >left( 2 ight) & = 25115.14901hspace <0.25in>Rightarrow hspace<0.25in>hspace<0.25in>M = 25116end]

We rounded to make the computations simpler. Note however, that this does not need to be done.

Here are the bounds for each rule.

In each case we can see that the errors are significantly smaller than the actual bounds.

## References

Babuška, I., Strouboulis, T.: Computational Integration. Oxford University Press, New York (2001)

Bader, M.: Space-Filling Curves. An Introduction with Applications in Scientific Computing. Springer, Berlin, Heidelberg (2013)

Benabidallah, A., Cherruault, Y., Mora, G.: Approximation of multiple integrals by length of alpha-dense curves. Kybernetes 31(7/8), 1133–1147 (2002)

Benabidallah, A., Cherruault, Y., Tourbier, T.: Approximation method error of multiple integrals by simple integrals. Kybernetes 32(3), 343–353 (2003)

Breinholt, G., Schierz, C.: Algorithm 781: generating hilbert’s space-filling curve by recursion. ACM Trans. Math. Softw. 32(3), 184–189 (1998)

Caflisch, R.E.: Monte carlo and quasi-monte carlo methods. Acta Numer. 7, 1–49 (1998)

Cherruault, Y., Mora, G.: Optimisation Globale. Théorie des Courbes (alpha ) -denses, Económica, Paris, (2005)

Cherruault, Y., Mora, G., Tourbier, Y.: A new method for calculating multiple integrals. Kybernetes 31(1), 124–129 (2002)

Dick, J., Kuo, F.Y., Sloan, I.H.: High-dimensional integration: the quasi-monte carlo way. Acta Numer. 22, 133–288 (2013)

Evans, G.A.: Multiple quadrature using highly oscillatory quadrature methods. Comput. Acta Numer. 163(1), 1–13 (2004)

García, G.: Interpolation of bounded sequences by (alpha ) -dense curves. Interpolat. Approx. Sci. Comput. 2017(1), 1–8 (2017)

García, G., Mora, G., Redwitz, D.A.: Box-counting dimension computed by (alpha ) -dense curves. Fractals 25(5), 11 (2017)

Krommer, A.R., Ueberhuber, C.W.: Computational Integration. SIAM, Philadelphia (1998)

Kythe, P.K., Schäferkotter, M.R.: Handbook of Computational Methods for Integration. Champal & Hall CRC Press, USA (2005)

G. Mora, The Peano curves as limit of (alpha ) -dense curves. Rev. R. Acad. Cienc. Exactas Fís. Nat. Ser. A Math. RACSAM, 99 (1), 23–28 (2005)

Mora, G., Cherruault, Y.: Characterization and generation of (alpha ) -dense curves. Comput. Math. Appl. 33(9), 83–91 (1997)

Mora, G., Mira, J.A.: Alpha-dense curves in infinite dimensional spaces. Inter. J. of Pure App. Math. 5(4), 257–266 (2003)

G. Mora and D.A. Redtwitz, Densifiable metric spaces. Rev. R. Acad. Cienc. Exactas Fís. Nat. Ser. A Math. RACSAM 105 (1), 71–83, 2011

Mora, G., Benavent, R., Navarro, J.C.: Polynomial alpha-dense curves and multiple integration. Inter. J. of Comput. Num. Anal. 1, 55–68 (2002)

Mora, G., Cherruault, Y., Benabidallah, A., Tourbier, Y.: Approximating multiple integrals via (alpha ) -dense curves. Kybernetes 31(2), 292–304 (2002)

Mora, G., Mora Porta, G.: Dimensionality reducing multiple integrals by alpha-dense curves. Int. J. Pure Appl. Math. 22(1), 103–104 (2005)

Neiderreiter, H.: Random Numbers Generation and Quasi-Monte Carlo Methods. Society for Industrial and Applied Mathematics (SIAM), Philadelphia (1992)

Proinov, P.C.: Discrepancy and integration of continuous functions. J. Approx. Theory 52(2), 121–131 (1988)

Sagan, H.: Space-filling Curves. Springer-Verlag, New York (1994)

Severino, J.S., Allen, E.J., Victory, H.D.: Acceleration of quasi-monte carlo approximations with applications in mathematical finance. Appl. Math. Comput. 148(1), 173–187 (2004)

Strobin, F.: Some porous and meager sets of continuous mappings. J. Nonlinear Convex Anal. 13(2), 351–361 (2012)

Ziadi, R., Bencherif-Madani, A., Ellaia, A.: Continuous global optimization through the generation of parametric curves. Appl. Math. Comput. 282(5), 65–83 (2016)

Wiener, N.: The Fourier Integral and Certain of its Applications. Cambridge University Press, Cambridge (1988)

## THE APPROXIMATION OF MULTIPLE INTEGRALS BY USING INTERPOLATORY CUBATURE FORMULAE

This chapter discusses the approximation of multiple integrals by using interpolatory cubature formula. It presents a survey of the theory of interpolatory cubature formulae that has been developed after 1970. In the chapter the following are considered: lower bounds for the number of knots of cubature formula, which are exact for polynomials of some fixed degree, the connection between orthogonal polynomials and cubatureformulae, the method of reproducing kernels, and invariant formula. The extension of cubature formulae of Gaussian type for the multivariate case is important in the theory of interpolatory cubature formula. If two polynomials of degree k orthogonal with respect to Ω and weight-function p (x, y) have exactly k 2 roots in common, finite and distinct, then these roots can be taken as knots of a cubature formula for an integral on Ω with the weight-function p (x, y). This formula is exact for all polynomials of degree not higher than 2k - 1.

## 3.4: Numerical Approximation of Multiple Integrals - Mathematics

In this chapter we’ve spent quite a bit of time on computing the values of integrals. However, not all integrals can be computed. A perfect example is the following definite integral.

We now need to talk a little bit about estimating values of definite integrals. We will look at three different methods, although one should already be familiar to you from your Calculus I days. We will develop all three methods for estimating

by thinking of the integral as an area problem and using known shapes to estimate the area under the curve.

Let’s get first develop the methods and then we’ll try to estimate the integral shown above.

#### Midpoint Rule

This is the rule that should be somewhat familiar to you. We will divide the interval (left[ ight]) into (n) subintervals of equal width,

We will denote each of the intervals as follows,

Then for each interval let (x_i^*) be the midpoint of the interval. We then sketch in rectangles for each subinterval with a height of (fleft( ight)). Here is a graph showing the set up using (n = 6). We can easily find the area for each of these rectangles and so for a general (n) we get that,

Or, upon factoring out a (Delta x) we get the general Midpoint Rule.

#### Trapezoid Rule

For this rule we will do the same set up as for the Midpoint Rule. We will break up the interval (left[ ight]) into (n) subintervals of width,

Then on each subinterval we will approximate the function with a straight line that is equal to the function values at either endpoint of the interval. Here is a sketch of this case for (n = 6). Each of these objects is a trapezoid (hence the rule’s name…) and as we can see some of them do a very good job of approximating the actual area under the curve and others don’t do such a good job.

The area of the trapezoid in the interval (left[ <<>>,> ight]) is given by,

So, if we use (n) subintervals the integral is approximately,

Upon doing a little simplification we arrive at the general Trapezoid Rule.

Note that all the function evaluations, with the exception of the first and last, are multiplied by 2.

#### Simpson’s Rule

This is the final method we’re going to take a look at and in this case we will again divide up the interval (left[ ight]) into (n) subintervals. However, unlike the previous two methods we need to require that (n) be even. The reason for this will be evident in a bit. The width of each subinterval is,

In the Trapezoid Rule we approximated the curve with a straight line. For Simpson’s Rule we are going to approximate the function with a quadratic and we’re going to require that the quadratic agree with three of the points from our subintervals. Below is a sketch of this using (n = 6). Each of the approximations is colored differently so we can see how they actually work. Notice that each approximation actually covers two of the subintervals. This is the reason for requiring (n) to be even. Some of the approximations look more like a line than a quadratic, but they really are quadratics. Also note that some of the approximations do a better job than others. It can be shown that the area under the approximation on the intervals (left[ <<>>,> ight]) and (left[ <,<>>> ight]) is,

If we use (n) subintervals the integral is then approximately,

Upon simplifying we arrive at the general Simpson’s Rule.

In this case notice that all the function evaluations at points with odd subscripts are multiplied by 4 and all the function evaluations at points with even subscripts (except for the first and last) are multiplied by 2. If you can remember this, this is a fairly easy rule to remember.

Okay, it’s time to work an example and see how these rules work.

First, for reference purposes, Mathematica gives the following value for this integral.

In each case the width of the subintervals will be,

and so the subintervals will be,

Let’s go through each of the methods.

Remember that we evaluate at the midpoints of each of the subintervals here! The Midpoint Rule has an error of 1.96701523.

The Trapezoid Rule has an error of 4.19193129

The Simpson’s Rule has an error of 0.90099869.

None of the estimations in the previous example are all that good. The best approximation in this case is from the Simpson’s Rule and yet it still had an error of almost 1. To get a better estimation we would need to use a larger (n). So, for completeness sake here are the estimates for some larger value of (n).

 Midpoint Trapezoid Simpson’s (n) Approx. Error Approx. Error Approx. Error 8 15.9056767 0.5469511 17.5650858 1.1124580 16.5385947 0.0859669 16 16.3118539 0.1407739 16.7353812 0.2827535 16.4588131 0.0061853 32 16.4171709 0.0354568 16.5236176 0.0709898 16.4530297 0.0004019 64 16.4437469 0.0088809 16.4703942 0.0177665 16.4526531 0.0000254 128 16.4504065 0.0022212 16.4570706 0.0044428 16.4526294 0.0000016

In this case we were able to determine the error for each estimate because we could get our hands on the exact value. Often this won’t be the case and so we’d next like to look at error bounds for each estimate.

These bounds will give the largest possible error in the estimate, but it should also be pointed out that the actual error may be significantly smaller than the bound. The bound is only there so we can say that we know the actual error will be less than the bound.

So, suppose that (left| ight| le K) and (left| <>left( x ight)> ight| le M) for (a le x le b) then if (), (), and () are the actual errors for the Midpoint, Trapezoid and Simpson’s Rule we have the following bounds,

We already know that (n = 4), (a = 0), and (b = 2) so we just need to compute (K) (the largest value of the second derivative) and (M) (the largest value of the fourth derivative). This means that we’ll need the second and fourth derivative of (fleft( x ight)).

Here is a graph of the second derivative. Here is a graph of the fourth derivative. So, from these graphs it’s clear that the largest value of both of these are at (x = 2). So,

[eginf''left( 2 ight) & = 982.7667hspace<0.25in>hspace <0.25in>Rightarrow hspace<0.25in>hspace<0.25in>K = 983 >left( 2 ight) & = 25115.14901hspace <0.25in>Rightarrow hspace<0.25in>hspace<0.25in>M = 25116end]

We rounded to make the computations simpler. Note however, that this does not need to be done.

Here are the bounds for each rule.

In each case we can see that the errors are significantly smaller than the actual bounds.

## Approximation of integrals and derivatives.

Integration is extremely important in applications, but very rarely is it possible to obtain the exact value of a definite integral since this requires an anti-derivative of the function. When one cannot find the anti-derivative, an approximation method is needed. The definition of the definite integral involves the limit of sums involving evaluations of the function (cf. also Riemann integral Integral sum), which provides a natural way for approximating the integral. It is a very inefficient procedure, however, and much better approximation methods are obtained by using an interpolating function to approximate the function and then integrating the interpolating function to produce the approximate value for the integral. The interpolating functions that are generally used are polynomials or piecewise polynomials. Numerical integration procedures are generally stable and can be designed to incorporate accuracy checks to modify the technique if it is suspected that the approximation is not sufficiently accurate.

Since the definition of the derivative involves the limit of the ratio of the change in the values of a function with respect to the change in its variable, the basic derivative approximation techniques use a difference quotient to approximate the derivative of a given function. However, numerical differentiation is generally unstable with respect to round-off error, and, unless care is used, the resulting approximations may be meaningless.

## 3.4: Numerical Approximation of Multiple Integrals - Mathematics

Numerical integration is much more reliable process compared to numerical differentiation. The round-off error in computing the sum of values I k , where k = 0,1. n, is always constant which does not depend on the rule of numerical integration. This constant is bounded by the product of the integration interval T and the maximal round-off error e r in computer's representation of numbers. Thus, if the truncation error of the numerical integration rule can be reduced by a recursive algorithm (see Lecture 3.5), the resulting numerical approximation represents the exact value of the integral accurately subject to a constant total round-off error.

The truncation error can be reduced by two different ways: by reducing the step size h and by using the higher-order integration formula of the order of O(h 2 ), O(h 4 ), and so on. If the step size h between two adjacent values I k becomes smaller, the truncation error of the numerical integration rule decays. For example, if the step size is reduced by half, the global truncation error of the composite trapezoidal rule is reduced by four. The figure below presents the results from the use of two composite trapezoidal rules on the current I = I(t) (view the data values for the current). The approximations are obtained with step size h = 10 (green pluses) and with step size h = 5 (blue dots), versus the exact integral S T [I(t)] (red solid curve). The error of the composite trapezoidal rule clearly reduces with smaller step size h (blue dots are closer to the exact red curve compared to the green pluses).

The figure also shows that the truncation error for the integral grows with the length of the interval. It is the global truncation error of numerical integration over the interval t = 0 and t = T. The global truncation error is distinguished from the local truncation error, the latter error occurs when the integral between two adjacent points is replaced by a trapezoid.

In many cases, the data samples are given with a fixed step size h that can not be controled. If this is the case, the numerical approximation for the integral can be improved by using a higher-order integration rule, such as the Simpson's rule. Romberg integration algorithm (see Lecture 3.5) allows to construct a sequence of higher-order integration rules starting with few computations of the composite trapezoidal rule. The figure below presents comparison of the composite trapezoidal rule (green pluses) and the composite Simpson's rule (blue dots) for the integral of the current I = I(t). The step size h is the same for both the numerical integrations: h = 10. The exact integral S T [I(t)] is shown by red solid curve. The composite Simpson's rule is clearly much more accurate than the composite trapezoidal rule.

## 3.4: Numerical Approximation of Multiple Integrals - Mathematics

> endstream endobj 24 0 obj 1382 endobj 22 0 obj > /ProcSet 2 0 R >> /Contents 23 0 R >> endobj 27 0 obj > stream J.+gME)=>9"rdt?634UY(320^N52/"@4Nr*[email protected]#.R_91Bcr!t%#'K9:,s B,EPGb(_p=g_.RNWqh5Tr8H)G-:+iGF]3KjolU>W=(bhL-6e$ZTYbY/), a6k(CbE W/KZVY1B0b/n8& >)]o5Fi*6'T?!m.&5^OO2q8:\_a0S40p!(_:$4=*JCD*?K! +_rVHL7t(L(5=BP:7&U"Wc#,%_f4JtN'[email protected]@[email protected] @?>"SNK0CL$Ojptj>P&0OCmjh_5iZjNt(k=$TI:_n]dT[=5R+fJ4"KEGoQl3%]X (_j:WE+0LkdmUjT%]a]+&.Qei[email protected]#JO!HSMkZl/i35cS-A+oGS'L4*JWjL. UT"$DK$b[^rp_!/qW8WG#-R5(ffh0u(VF5leUEbN/hZ'51np"i88VpPgC+$o3Nq *+^(JUKf5A%M0c>4:NNNHFV-CI'YEO'GHB^"tiSA)+ :rrL1/U! M_Ve6Q$"piH! 8kPlTqW!dj,D0=)6(HFBVi'F'U59e *MZ!dqOsOVmuD)[email protected][email protected]^44,j1L?_?l['$V[IJ][email protected]?Ot.iK/'0OVA,0- #[email protected]%f4!Bg'7dA&3uSX%)L&g0M3.4: Numerical Approximation of Multiple Integrals - Mathematics,[nobr][H1toH2][email protected](cr$G.1:^Q -4%[email protected]:r^r#kApYg-8KQ,oW_e6X_%4!qhYSmlBK6U]=kGh.LHP-psXa :[email protected],eg4EG(GQ^#&YJ_0E:#i?Shhciq&a>OLOZdOa]^ucJ1Ei]H$V/2S&AKo- * [email protected]:4H^tg 'Z(!/T[s%"[email protected] oBYaZF&XXR="f$Ih.K'qC"F#s_uSTFCQ i#Xgp[2UZ26jCTn9S7mMN^,TmB8pTRKMi.)WPFONFMT"TI+['+dl7iE."J#n

> endstream endobj 79 0 obj 2354 endobj 77 0 obj > /ProcSet 2 0 R >> /Contents 78 0 R >> endobj 81 0 obj > stream J.+gME)=>9"rdt?634UY(320^N52/"@4Nr*[email protected]#.R_91Bcr!t%#'K9:,s B,EPGb(_p=g_.RN^k:VTr8H*6Frg+f >o"L-!l8Qg=> #A92I6oK[ZQ fsF'SSl[S5^==^MUccJCHUR(85-O=CFDZO(Y%tYf2]qjG)[Ye2K8%_/XG,EG$Yq CZc-&4MI^QA_ [email protected]@PORJEBM_qN6kKhr&]=^.r/X)KRjcaaXm7P,3$R!O/d2?=hE$Y6+PnmX +d5G9K`a"o16,[email protected]!>r%NnZ6V?XlP>T8Es18G?C+:>0$K2!?MB^+s 16&3k18Och8h*H/,f,(7bGgHl3iU?FUs,[email protected]_rLL7u[b1s&X+dZ9hK(0p/lYRFh 469m"MfCAO[g-Ju' fXKEHteBL=X47SS! 12Q)6?]9Pi]R:Y%u ,r5V-d#!13+sMTHF

> endstream endobj 82 0 obj 878 endobj 80 0 obj > /ProcSet 2 0 R >> /Contents 81 0 R >> endobj 7 0 obj > endobj 8 0 obj > endobj 9 0 obj > endobj 10 0 obj > endobj 17 0 obj > endobj 18 0 obj > endobj 26 0 obj > endobj 2 0 obj [ /PDF /Text ] endobj 5 0 obj > endobj 33 0 obj > endobj 52 0 obj > endobj 71 0 obj > endobj 83 0 obj > endobj 1 0 obj > endobj 3 0 obj > endobj xref 0 84 0000000000 65535 f 0000070829 00000 n 0000070267 00000 n 0000070976 00000 n 0000003061 00000 n 0000070298 00000 n 0000003214 00000 n 0000069405 00000 n 0000069531 00000 n 0000069656 00000 n 0000069761 00000 n 0000000010 00000 n 0000003040 00000 n 0000007340 00000 n 0000004406 00000 n 0000007319 00000 n 0000009933 00000 n 0000069889 00000 n 0000070017 00000 n 0000007483 00000 n 0000009912 00000 n 0000010043 00000 n 0000011626 00000 n 0000010129 00000 n 0000011605 00000 n 0000013676 00000 n 0000070141 00000 n 0000011783 00000 n 0000013655 00000 n 0000016719 00000 n 0000013843 00000 n 0000016698 00000 n 0000020786 00000 n 0000070406 00000 n 0000016862 00000 n 0000020765 00000 n 0000025187 00000 n 0000020930 00000 n 0000025166 00000 n 0000027843 00000 n 0000025331 00000 n 0000027822 00000 n 0000031089 00000 n 0000027987 00000 n 0000031068 00000 n 0000034521 00000 n 0000031244 00000 n 0000034500 00000 n 0000040026 00000 n 0000034676 00000 n 0000040005 00000 n 0000043539 00000 n 0000070516 00000 n 0000040170 00000 n 0000043518 00000 n 0000047490 00000 n 0000043683 00000 n 0000047469 00000 n 0000050087 00000 n 0000047645 00000 n 0000050066 00000 n 0000052249 00000 n 0000050230 00000 n 0000052228 00000 n 0000054887 00000 n 0000052381 00000 n 0000054866 00000 n 0000058747 00000 n 0000055042 00000 n 0000058726 00000 n 0000062206 00000 n 0000070626 00000 n 0000058902 00000 n 0000062185 00000 n 0000065475 00000 n 0000062361 00000 n 0000065454 00000 n 0000068099 00000 n 0000065630 00000 n 0000068078 00000 n 0000069247 00000 n 0000068255 00000 n 0000069227 00000 n 0000070722 00000 n trailer > startxref 71026 %%EOF

This is one of over 2,400 courses on OCW. Explore materials for this course in the pages linked along the left.

MIT OpenCourseWare is a free & open publication of material from thousands of MIT courses, covering the entire MIT curriculum.

No enrollment or registration. Freely browse and use OCW materials at your own pace. There's no signup, and no start or end dates.

Knowledge is your reward. Use OCW to guide your own life-long learning, or to teach others. We don't offer credit or certification for using OCW.

Made for sharing. Download files for later. Send to friends and colleagues. Modify, remix, and reuse (just remember to cite OCW as the source.) 