IntegrateData2D - Maple Help

All Products Maple MapleSim

Home : Support : Online Help : Science and Engineering : Signal Processing : Computing Statistics : IntegrateData2D

SignalProcessing

IntegrateData2D

calculate the volume under a 2-D data set

	Calling Sequence
	IntegrateData2D( X, Y, Z, options ) IntegrateData2D( Z, options )

Parameters

X, Y	-	one-dimensional rtables or lists of independent data values of type realcons
Z	-	two-dimensional rtable or list of dependent data values of type complexcons

Options

•	method: One of bottomleftcorner, topleftcorner, toprightcorner, bottomrightcorner, averagecorner, and simpson. The default is averagecorner.

•	sortdata: Either true or false, specifies if the data is to be sorted. The default is true.

•	steps: List of two numeric values, specifies the constant spacing of the independent data for the IntegrateData2D(Z) calling sequence. The default is [1,1].

•	tolerance: Positive numeric value which specifies the tolerance for determining if the independent data in X and Y are uniformly spaced. The default is HFloat(5,-15).

•	uniform: Either true or false, specifies if the independent data in X and Y are to be assumed uniform. The default is false.

Description

•	The IntegrateData2D command approximates the volume beneath a 2-D data set using the specified method.

•	For the IntegrateData2D(X,Y,Z) calling sequence, Z must have numelems(X) rows and numelems(Y) columns. The values of Z are assumed to have been generated by some hypothetical function $f (x, y)$ and satisfy $Z_{i, j} = f (X_{i}, Y_{j})$ for each $i$ and $j$ .

•	Units are supported in the values of steps and the containers X, Y, and Z (when the rtable shape is a unit).

•	Internally, the complex case (where Z is complex) is reduced to the real case by applying IntegrateData2D separately to the real and imaginary parts of Z. That is:

$IntegrateData2D (X, Y, Z) = IntegrateData2D (X, Y, ℜ (Z)) + I IntegrateData2D (X, Y, ℑ (Z))$

For the discussion below, assume the values in Z are real-valued.

•	When method is any of the "corner methods" and Z has less than two rows or columns, or when method is simpson and Z has less than three rows or columns, the result will be Float(undefined).

•

Suppose sortdata=true. For the IntegrateData2D(X,Y,Z) calling sequence, X and Y are sorted to be in non-decreasing order and Z is sorted in tandem. For the IntegrateData2D(Z) calling sequence, if one or both values in steps is negative, then the absolute values of these widths is used, and the elements of Z are sorted accordingly. For example, if ${steps}_{1} < 0$ and $0 < {steps}_{2}$ , then the rows of Z are sorted in reverse order.

•

When sortdata=false, the onus is on the user to ensure that the data passed is sorted. For the IntegrateData2D(X,Y,Z) calling sequence, if the data is in fact not sorted, then the result may be useless. For example, if method=simpson and $X_{i + 1} = X_{i}$ for some $i$ , then a division by zero occurs and the computed volume will be Float(undefined).

•

For the IntegrateData2D(X,Y,Z) calling sequence, when uniform=true, it is assumed that X and Y are uniformly spaced, with respective spacings $X_{2} - X_{1}$ and $Y_{2} - Y_{1}$ . When uniform=false, however, the procedure first checks if X and Y are uniform before deciding which auxiliary procedure to use to compute the volume. For X to be considered uniformly spaced, for example, it must satisfy $|Δ_{i} - Δ_{j}| \leq τ$ for each $i$ and $j$ , where $Δ_{i} = X_{i + 1} - X_{i}$ and $τ = tolerance$ .

•

Computations using regular/uniform data, compared with irregular/non-uniform data, tend to be quicker and have smaller numerical error in the final result. Regarding speed, for one of the "corner methods" with a fixed number of values in X and Y, the computation typically takes twice as long if X and Y are irregular than if they are regular. For Simpson's Method, the time taken for irregular data is approximately quadruple the time taken for regular data.

•	The main computations are handled by external C code.

•	For any of the "corner methods", the following formula is used:

$IntegrateData2D (X, Y, Z) = \sum_{i = 1}^{m - 1} \sum_{j = 1}^{n - 1} z_{i, j} (X_{i + 1} - X_{i}) (Y_{i + 1} - Y_{i})$

where $m = numelems (X)$ and $n = numelems (Y)$ . For method=bottomleftcorner:

$z_{i, j} = Z_{i, j}$

For method=topleftcorner:

$z_{i, j} = Z_{i, j + 1}$

For method=toprightcorner:

$z_{i, j} = Z_{i + 1, j + 1}$

For method=bottomrightcorner:

$z_{i, j} = Z_{i + 1, j}$

For method=averagecorner:

$z_{i, j} = \frac{Z_{i, j} + Z_{i, j + 1} + Z_{i + 1, j} + Z_{i + 1, j + 1}}{4}$

Note: method=averagecorner is the 2-D analogue of the Trapezoid Method in 1-D, and for a given sub-box consisting of $X_{i}$ , $X_{i + 1}$ , $Y_{j}$ , and $Y_{j + 1}$ , the volume is that of the best-fit plane through the four points.

•

We will omit the long and complicated formulas for method=simpson, and include only a description of the derivation. Suppose first that m and n are odd, where $m = numelems (X)$ and $n = numelems (Y)$ . Now, partition the grid into non-overlapping sub-boxes with nine points each, formed by points consisting of $X_{p}$ , $X_{p + 1}$ , $X_{p + 2}$ , $Y_{q}$ , $Y_{q + 1}$ , and $Y_{q + 2}$ , where $p = 1 .. \frac{m - 1}{2}$ and $q = 1 .. \frac{n - 1}{2}$ . The formula for the approximate volume over one of these sub-boxes is found by integrating over the sub-box the unique quadratic bivariate polynomial which interpolates these nine points. When one or more of m and n is even, however, sub-boxes of nine points are again considered, but the integration is performed only over the parts that have not yet been counted using the above method.

•

Any input rtable/list of independent data is converted to an rtable of float[8] datatype having no infinite or undefined values, and an error is thrown if this is not possible. Similarly, the input rtable/list of dependent data is converted to an rtable of either float[8] or complex[8] datatype having no infinite or undefined values, and an error is thrown if this is not possible. For this reason, it is most efficient for any input to already be an rtable having the appropriate datatype. Note: The rtables cannot have a non-unit indexing function, and they need to have rectangular storage.

•	The IntegrateData2D command is not thread safe.

Examples

>	$with (SignalProcessing) &colon;$

Example 1

•	Consider this quadratic bivariate polynomial:

>	$p ≔ (x, y) \mapsto 3 - 2 \cdot x + 5 \cdot y + 4 \cdot x^{2} - 10 \cdot y \cdot x + 7 \cdot y^{2}$

$p ≔ (x, y) \mapsto 3 - 2 \cdot x + 5 \cdot y + 4 \cdot x^{2} - 10 \cdot y \cdot x + 7 \cdot y^{2}$

(1)

>	$a ≔ 0 &colon;$

>	$b ≔ 10 &colon;$

>	$c ≔ 0 &colon;$

>	$d ≔ 20 &colon;$

>	$plot3d (p, a .. b, c .. d)$

•	First, create sample points:

>	$m ≔ 7 &colon;$

>	$n ≔ 13 &colon;$

>	$dx ≔ evalhf (\frac{b - a}{m - 1}) &colon;$

>	$dy ≔ evalhf (\frac{d - c}{n - 1}) &colon;$

>	$X ≔ Vector (m, i \mapsto evalhf (a + (i - 1) \cdot dx),'datatype' ='float [8]')$

$X ≔ [\begin{array}{c} 0. \\ 1.66666666666667 \\ 3.33333333333333 \\ 5. \\ 6.66666666666667 \\ 8.33333333333333 \\ 10. \end{array}]$

(2)

>	$Y ≔ Vector (n, j \mapsto evalhf (c + (j - 1) \cdot dy),'datatype' ='float [8]')$

>	$Z ≔ Matrix (m, n, (i, j) \mapsto evalhf (p (X [i], Y [j])),'datatype' ='float [8]')$

•	Now, compute the volume using Simpson's Method:

>	$α ≔ IntegrateData2D (X, Y, Z,'uniform','method' ='simpson')$

$α ≔ 121933.333333333358$

(3)

•	Since the independent data values are uniformly spaced, we can also use the other calling sequence:

>	$IntegrateData2D (Z,'steps' = [dx, dy],'method' ='simpson')$

$121933.333333333358$

(4)

•	Since Simpson's Method gives the exact answer for such cases, we can compare the result of IntegrateData2D with the expected answer:

>	$β ≔ evalf [15] (int (p (x, y), x = a .. b, y = c .. d))$

$β ≔ 121933.333333333$

(5)

Example 2

•	Consider the following function:

>	$f ≔ (x, y) \mapsto \exp (\frac{1}{1 + x^{2} + y^{2}})$

$f ≔ (x, y) \mapsto {&ExponentialE;}^{\frac{1}{1 + x^{2} + y^{2}}}$

(6)

>	$plot3d (f, 0. .. 10, 0. .. 10.0)$

•	With a uniform spacing of 1.0, Simpson's Method gives the following:

>	$X ≔ Vector ([seq (0. .. 10.0, 1.0)],'datatype' ='float [8]') &colon;$

>	$Y ≔ X &colon;$

>	$Z ≔ Matrix (numelems (X), numelems (Y), (i, j) \mapsto evalhf (f (X [i], Y [j])),'datatype' ='float [8]') &colon;$

>	$α ≔ IntegrateData2D (X, Y, Z,'method' ='simpson')$

$α ≔ 104.150606423932388$

(7)

•	This approximation for the volume is good, but it could be better, as we can see from integrating the original function:

>	$ξ ≔ int (f (x, y), x = 0. .. 10.0, y = 0. .. 10.0,'numeric','digits' = 15)$

$ξ ≔ 104.263869308879$

(8)

>	$evalhf (abs (α - ξ))$

$0.113262884946607301$

(9)

•	From the plot of the dependent data, we can see that more samples for $x$ and $y$ between 0.0 and 3.0 will improve the approximate volume found:

>	$plots :- matrixplot (Z)$

•	Since we have the access to the original function, we have the luxury of being able to sample more densely for smaller $x$ and $y$ :

>	$U ≔ Vector ([seq (0. .. 3.0, 0.01), seq (4.0 .. 10.0, 1.0)],'datatype' ='float [8]') &colon;$

>	$V ≔ U &colon;$

>	$W ≔ Matrix (numelems (U), numelems (V), (i, j) \mapsto evalhf (f (U [i], V [j])),'datatype' ='float [8]') &colon;$

>	$β ≔ IntegrateData2D (U, V, W,'method' ='simpson')$

$β ≔ 104.264569012844262$

(10)

•	This approximation is much closer:

>	$evalhf (abs (β - ξ))$

$0.000699703965267417516$

(11)

Example 3

>	$m ≔ 3 &colon;$

>	$n ≔ 3 &colon;$

>	$X ≔ [seq (1 .. m)]$

$X ≔ [1, 2, 3]$

(12)

>	$Y ≔ [seq (1 .. n)]$

$Y ≔ [1, 2, 3]$

(13)

>	$Z ≔ Matrix (m, n, [seq (1 .. m n)])$

$Z ≔ [\begin{array}{c} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{array}]$

(14)

>	$IntegrateData2D (X, Y, Z,'method' ='bottomleftcorner')$

$12.$

(15)

Example 4

•	Consider the following function and box:

>	$f ≔ (x, y) \mapsto sqrt (1 + \sin (π \cdot (x^{2} + 3 \cdot y^{2})))$

$f ≔ (x, y) \mapsto \sqrt{1 + \sin (π \cdot (x^{2} + 3 \cdot y^{2}))}$

(16)

>	$a ≔ 0. &colon;$

>	$b ≔ 1.0 &colon;$

>	$c ≔ - 0.5 &colon;$

>	$d ≔ 1.5 &colon;$

>	$plot3d (f, a .. b, c .. d)$

•	Now, create a Matrix of sample data points:

>	$m ≔ 1000 &colon;$

>	$n ≔ 1000 &colon;$

>	$dx ≔ evalhf (\frac{b - a}{m - 1}) &colon;$

>	$dy ≔ evalhf (\frac{d - c}{n - 1}) &colon;$

>	$Z ≔ Matrix (m, n, (i, j) \mapsto evalhf (f (a + (i - 1) \cdot dx, c + (j - 1) \cdot dy)),'datatype' ='float [8]') &colon;$

•	Finally, approximate the volume, using two different methods:

>	$u ≔ CodeTools :- Usage (IntegrateData2D (Z,'steps' = [dx, dy],'method' ='averagecorner'))$

memory used=7.66MiB, alloc change=7.63MiB, cpu time=9.00ms, real time=9.00ms, gc time=0ns

$u ≔ 2.06220791967658945$

(17)

>	$v ≔ CodeTools :- Usage (IntegrateData2D (Z,'steps' = [dx, dy],'method' ='simpson'))$

memory used=7.66MiB, alloc change=7.63MiB, cpu time=9.00ms, real time=8.00ms, gc time=0ns

$v ≔ 2.06221208164538305$

(18)

Example 5

•	Here, will use unsorted and irregular (not uniform) independent data:

>	$f ≔ (x, y) \mapsto 1.76965408823860471 + 0.0769328086078387985 \cdot x - 2.65475838418437826 \cdot y - 4.27801178528191528 \cdot x^{2} - 6.15468302818204016 \cdot y \cdot x + 7.04479517210091011 \cdot y^{2}$

$f ≔ (x, y) \mapsto 1.76965408823860471 + 0.0769328086078387985 \cdot x - 2.65475838418437826 \cdot y - 4.27801178528191528 \cdot x^{2} - 6.15468302818204016 \cdot y \cdot x + 7.04479517210091011 \cdot y^{2}$

(19)

$X ≔ Array ([2.44882197894116, 0.934363022771893, 3.97599950568532, 3.82758394074501, 1.90779228546504, 0., 2.19372179828199, 0.172230402514544, 4.75111024419177, 5.0, 1.58549740030430, 3.47414311487909, 4.11728914163646, 0.485658906179238, 0.230856953155770, 1.38461492480445, 0.159164231887103, 3.53023044009804, 0.855933439057809, 3.27738945088778],'datatype' ='float [8]')$

$X ≔ [\begin{array}{c} 2.44882197894116 & 0.934363022771893 & 3.97599950568532 & 3.82758394074501 & 1.90779228546504 & 0. & 2.19372179828199 & 0.172230402514544 & 4.75111024419177 & 5. & 1.58549740030430 & 3.47414311487909 & 4.11728914163646 & 0.485658906179238 & 0.230856953155770 & 1.38461492480445 & 0.159164231887103 & 3.53023044009804 & 0.855933439057809 & 3.27738945088778 \end{array}]$

(20)

$Y ≔ Array ([6.99076722656686, 10.0, 5.05957051665142, 2.55095115459269, 7.51267059305653, 2.23811939491137, 5.85267750979777, 3.40385726666133, 9.59743958516081, 4.98364051982143, 1.18997681558377, 1.62611735194631, 6.55098003973841, 6.79702676853675, 0., 2.76025076998578, 7.54686681982361, 7.09364830858073, 6.46313010111265, 4.45586200710899],'datatype' ='float [8]')$

$Y ≔ [\begin{array}{c} 6.99076722656686 & 10. & 5.05957051665142 & 2.55095115459269 & 7.51267059305653 & 2.23811939491137 & 5.85267750979777 & 3.40385726666133 & 9.59743958516081 & 4.98364051982143 & 1.18997681558377 & 1.62611735194631 & 6.55098003973841 & 6.79702676853675 & 0. & 2.76025076998578 & 7.54686681982361 & 7.09364830858073 & 6.46313010111265 & 4.45586200710899 \end{array}]$

(21)

>	$Z ≔ Array (1 .. numelems (X), 1 .. numelems (Y), (i, j) \mapsto evalhf (f (X [i], Y [j])),'datatype' ='float [8]')$

>	$plot3d (f, \min (X) .. \max (X), \min (Y) .. \max (Y))$

•	The expected answer, for comparison, is the following:

>	$α ≔ evalf [15] (int (f (x, y), x = \min (X) .. \max (X), y = \min (Y) .. \max (Y)))$

$α ≔ 5546.55319312876$

(22)

•	To approximate the volume, we will use two approaches. For the first approach, just use the sortdata option:

>	$ξ ≔ IntegrateData2D (X, Y, Z,'sortdata' ='true','method' ='simpson')$

$ξ ≔ 5546.55319312876418$

(23)

•	For the second approach, we will manually sort the data:

>	$P ≔ sort ['inplace'] (X,'output' ='permutation') &colon;$

>	$Q ≔ sort ['inplace'] (Y,'output' ='permutation') &colon;$

>	$Z ≔ Z [P, Q] &colon;$

>	$ζ ≔ IntegrateData2D (X, Y, Z,'sortdata' ='false','method' ='simpson')$

$ζ ≔ 5546.55319312876418$

(24)

Example 6

•	In this example, we show that IntegrateData2D gives the exact answer when the data is generated by a plane.

>	$φ ≔ (x, y) \mapsto 5.89801239837002367 \cdot x + 6.33497857715261770 \cdot y - 3.14488365480468168$

$φ ≔ (x, y) \mapsto 5.89801239837002367 \cdot x + 6.33497857715261770 \cdot y - 3.14488365480468168$

(25)

>	$a ≔ 0. &colon;$

>	$b ≔ 10.0 &colon;$

>	$c ≔ 0. &colon;$

>	$d ≔ 5.0 &colon;$

>	$plot3d (φ, a .. b, c .. d)$

•	For comparison, the int command gives the following:

>	$ν ≔ evalf [15] (int (φ (x, y), x = a .. b, y = c .. d))$

$ν ≔ 2109.13123899635$

(26)

•	Using IntegrateData2D with sorted regular data:

>	$m ≔ 15 &colon;$

>	$n ≔ 20 &colon;$

>	$X ≔ Vector (m, i \mapsto evalhf (a + \frac{(i - 1) \cdot (b - a)}{m - 1}),'datatype' ='float [8]') &colon;$

>	$Y ≔ Vector (n, j \mapsto evalhf (c + \frac{(j - 1) \cdot (d - c)}{n - 1}),'datatype' ='float [8]') &colon;$

>	$Z ≔ Matrix (m, n, (i, j) \mapsto evalhf (φ (X [i], Y [j])),'datatype' ='float [8]') &colon;$

>	$α ≔ IntegrateData2D (X, Y, Z,'uniform' ='true','sortdata' ='false','method' ='averagecorner')$

$α ≔ 2109.13123899635002$

(27)

•	Using IntegrateData2D with sorted irregular data:

>	$U ≔ Vector ([0., 0.344460805029088, 1.86872604554379, 3.17099480060861, 3.81558457093008, 4.38744359656398, 4.45586200710899, 4.89764395788231, 6.46313010111265, 6.94828622975817, 7.65516788149002, 7.95199901137063, 8.23457828327293, 9.50222048838355, 10.0],'datatype' ='float [8]') &colon;$

$V ≔ Vector ([0., 0.594988407791883, 0.813058675973153, 1.11905969745568, 1.27547557729635, 1.38012538499289, 1.70192863333067, 2.49182025991071, 2.52978525832571, 2.92633875489889, 3.27549001986920, 3.39851338426837, 3.49538361328343, 3.54682415429036, 3.75633529652826, 3.77343340991180, 4.45451626267899, 4.79645712602722, 4.79871979258041, 5.0],'datatype' ='float [8]') &colon;$

>	$W ≔ Matrix (numelems (U), numelems (V), (i, j) \mapsto evalhf (φ (U [i], V [j])),'datatype' ='float [8]') &colon;$

>	$β ≔ IntegrateData2D (U, V, W,'uniform' ='false','sortdata' ='false','method' ='averagecorner')$

$β ≔ 2109.13123899634866$

(28)

Example 7

•	The IntegrateData2D command also works with complex data. Here, we find the volume under ${&ExponentialE;}^{\sqrt{x^{2} - 1}}$ for $x$ and $y$ in the interval $[0, 2]$ :

>	$f ≔ (x, y) \mapsto \exp (sqrt (x^{2} - 1))$

$f ≔ (x, y) \mapsto {&ExponentialE;}^{\sqrt{x^{2} - 1}}$

(29)

>	$a ≔ 0 &colon;$

>	$b ≔ 2 &colon;$

>	$n ≔ 250 &colon;$

>	$h ≔ evalhf (\frac{b - a}{n - 1}) &colon;$

>	$Z ≔ Matrix (n, n, (i, j) \mapsto evalhf (f (a + (i - 1) \cdot h, a + (j - 1) \cdot h)),'datatype' ='complex [8]') &colon;$

>	$v ≔ IntegrateData2D (Z,'steps' = [h, h],'method' ='simpson')$

$v ≔ 7.74723830751058973 + 1.38245111945337396 I$

(30)

Example 8

•	Units are supported:

>	$X ≔ Vector ([1, 2, 3],'datatype' ='float [8]') Unit ('m')$

$X ≔ [\begin{array}{c} 1. ⟦m⟧ \\ 2. ⟦m⟧ \\ 3. ⟦m⟧ \end{array}]$

(31)

>	$Y ≔ Vector ([1, 3, 5],'datatype' ='float [8]') Unit ('s')$

$Y ≔ [\begin{array}{c} 1. ⟦s⟧ \\ 3. ⟦s⟧ \\ 5. ⟦s⟧ \end{array}]$

(32)

>	$Z ≔ Matrix ([[10, - 2, 5], [7, 0, 3], [- 1, 6, 4]],'datatype' ='float [8]') Unit ('kg')$

$Z ≔ [\begin{array}{c} 10. ⟦kg⟧ & - 2. ⟦kg⟧ & 5. ⟦kg⟧ \\ 7. ⟦kg⟧ & 0. & 3. ⟦kg⟧ \\ - 1. ⟦kg⟧ & 6. ⟦kg⟧ & 4. ⟦kg⟧ \end{array}]$

(33)

>	$h ≔ [1 Unit ('m'), 2 Unit ('s')]$

$h ≔ [⟦m⟧, 2 ⟦s⟧]$

(34)

>	$IntegrateData2D (X, Y, Z)$

$23. ⟦kg m s⟧$

(35)

>	$IntegrateData2D (Z,'steps' = h)$

$23. ⟦kg m s⟧$

(36)

Compatibility

•	Starting with Maple 2023, external C code is used for the auxiliary procedures that were formerly implemented in Maple and could be compiled by passing the compiled option. The compiled option is now deprecated, but it is still accepted for backwards compatibility.

•	The SignalProcessing[IntegrateData2D] command was introduced in Maple 2022.

•	For more information on Maple 2022 changes, see Updates in Maple 2022.

•	The SignalProcessing[IntegrateData2D] command was updated in Maple 2024.

Maple

Maple Add-Ons

MapleSim

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim

Maple

Powerful math software that is easy to use

Maple Add-Ons

MapleSim

Advanced System Level Modeling

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim