MaplePrimes - answers and comments on Question, Two random points in the unit cube

solution

Joe Riel — Sun, 19 Jun 2011 18:44:18 Z

You don't really need Maple for this, the computation is straightforward. However, it is easily done with Maple.

sqrt(sum(int((x1[k]-x2[k])^2, x1[k]=0..1, x2[k]=0..1), k=1..n));
                                    1/2  1/2
                                   6    n
                                   ---------
                                       6

where n is the number of dimensions.

In 3 dimensions

longrob — Sun, 19 Jun 2011 21:27:16 Z

1/105 * (4+17*sqrt(2)-6*sqrt(3)+21*log(1+sqrt(2))+84*log(1+sqrt(3))-42*log(2)-7*Pi);

0.6617071825

http://www.math.kth.se/~johanph/habc.pdf

http://www.math.kth.se/~johanph/Eabc.mw

Hypercube Line Picking

Alec Mihailovs — Sun, 19 Jun 2011 21:51:21 Z

See Eric Weisstein's page Hypercube Line Picking in the Mathworld.

Alec

Simulation

longrob — Mon, 20 Jun 2011 00:29:33 Z

Are you interested in simulating the result ?

Here's a crude monte-carlo simulation, for 3 dimensions:

t:=time():
N:=100000:
with(Statistics):
RV := RandomVariable(Uniform(0, 1)):
s:=0:

X[1]:=Sample(RV,N):
X[2]:=Sample(RV,N):
Y[1]:=Sample(RV,N):
Y[2]:=Sample(RV,N):
Z[1]:=Sample(RV,N):
Z[2]:=Sample(RV,N):
for i from 1 to N do
    s:=s+sqrt((X[1][i]-X[2][i])^2 +(Y[1][i]-Y[2][i])^2+(Z[1][i]-Z[2][i])^2);
end do:
s/N;

time()-t;

This compares well with the exact result I posted earlier.

For higher dimensions, we can easily adapt the code for an arbitrary number 
of dimensions, but obviously it will take loner to run . So, for d-dimensional space:


RV := RandomVariable(Uniform(0, 1)):
s:=0:
d:=5:
N:=10000:
for dim from 1 to d do
    A[dim]:=Sample(RV,N);
    B[dim]:=Sample(RV,N);
end do:

for i from 1 to N do
    s:=s+sqrt(sum((A[dimm][i]-B[dimm][i])^2,dimm=1..d))
end do:
s/N;

Numerical approximation

Alec Mihailovs — Mon, 20 Jun 2011 01:14:35 Z

Numerical approximation (up to 4 digits after the decimal dot) can be done in Maple as

f:=(x1,y1,x2,y2,x3,y3)->sqrt((x1-y1)^2+(x2-y2)^2+(x3-y3)^2):
evalf(Int(f,[(0..1)$6],method= _MonteCarlo,epsilon=0.5e-4));

                             0.6616946352

One-dimensional case can be done symbolically,

int(abs(x-y),[x=0..1,y=0..1]);

                                 1/3

Two-dimensional case can be done with 14 digits,

f:=unapply(simplify(int(sqrt((x-y)^2+c),[x=0..1,y=0..1])) ,c) assuming c>0;

                 (3/2)                    1/2
  f := c -> 2/3 c      - c ln(-1 + (c + 1)   ) + 1/2 c ln(c)

                        1/2              1/2
         - 2/3 c (c + 1)    + 1/3 (c + 1)

Digits:=14:
evalf(Int(f((x-y)^2),[x=0..1,y=0..1]));

                           0.52140543316473

or with higher precision after a slight modification of the integral,

Digits:=100:
4*eval(int(int(sqrt(x^2+y^2)*(1-x)*(1-y),x=0..1),y=0..1),csgn(y)=1);

       1
      /      4      3
     |      y      y          3     2         2     2
  4  |   - ---- + ---- + 1/4 y  ln(y ) - 1/4 y  ln(y )
     |      3      3
    /
      0

               2     3/2       2     1/2
           y (y  + 1)      y (y  + 1)           3          2     1/2
         + ------------- - ------------- - 1/2 y  ln(1 + (y  + 1)   )
                 3               2

             2     3/2     2     1/2
           (y  + 1)      (y  + 1)           2          2     1/2
         - ----------- + ----------- + 1/2 y  ln(1 + (y  + 1)   ) dy
                3             2

evalf(%);

  0.52140543316472067833098235660724397491403156777900834179621051\
        87505078933048158318679281329252614524

Maple has no problems with integrating symbolically the part of the integrand free of logarithms. It has problems with the following integral,

4*int(1/4*y^3*ln(y^2)-1/4*y^2*ln(y^2)-1/2*y^3*ln(1+(y^2+1)^(1/2))+1/2*y^2*ln(1+(y^2+1)^(1/2)),y = 0 .. 1)=1/2*2^(1/2)-1/3+1/3*ln(1+2^(1/2))+1/2*ln(2^(1/2)-1);

       1
      /
     |        3     2         2     2         3          2     1/2
  4  |   1/4 y  ln(y ) - 1/4 y  ln(y ) - 1/2 y  ln(1 + (y  + 1)   )
     |
    /
      0

                2          2     1/2
         + 1/2 y  ln(1 + (y  + 1)   ) dy =

         1/2
        2                        1/2            1/2
        ---- - 1/3 + 1/3 ln(1 + 2   ) + 1/2 ln(2    - 1)
         2

evalf(%);

                     0.2268778500 = 0.2268778498

Rewriting similarly the integral for the 3-dimensional case, we can evaluate it numerically more precisely,

8*int(int(int(sqrt(x^2+y^2+z^2)*(1-x)*(1-y)*(1-z),x=0..1),y=0..1),z=0..1):
evalf(%);

                             0.6617071822

Similarly, it works in higher dimensions up to n=7,

f:=n->evalf(2^n*Int(sqrt(add((x||i)^2,i=1..n))*mul(1-x||i,i=1..n),
    [seq(x||i=0..1,i=1..n)]));
seq(f(n),n=1..7);

  0.3333333334, 0.5214054332, 0.6617071822, 0.7776656536,
                                                      
        0.8785309152, 0.9689420832, 1.051583873

Alec

Another way

Markiyan Hirnyk — Mon, 20 Jun 2011 19:58:44 Z

The answer in MathWorld is great, but the origin of the formula for Δ(n) is unclear.
Another answer can simply be obtained. Let R1,..,Rn be mutually independent absolutely continuous
random variables with the densities p1(t),..pn(t) and f(t1,...,tn) be a measurable function on R^n. Then
the mean E(f(R1,...Rn)) equals the integral of f(t1,...,tn)*p1(t1)*...*pn(tn) over R^n. This formula is more known in the case n=1 and less known in the case n>1. Next,
> with(Statistics):
> X1 := RandomVariable(Uniform(0, 1)):
> X2 := RandomVariable(Uniform(0, 1)):
> Y1 := RandomVariable(Uniform(0, 1));
> Y2 := RandomVariable(Uniform(0, 1));
> Z1 := RandomVariable(Uniform(0, 1));
> Z2 := RandomVariable(Uniform(0, 1));
> R1 := X2-X1; R2 := Y2-Y1; R3 := Z2-Z1;
> R1 := X2-X1:
> PDF(R1, t);

piecewise(t <= -1, 0, t <= 0, t+1, t <= 1, 1-t, 1 < t, 0)

The PDF(R2,t) and PDF(R3,t) are the same. We put
>dist := sqrt(t1^2+t2^2+t3^2):
Applying the above mentioned formula, we obtain that the mean E(sqrt((X2-X1)^2+(Y2-Y1)^2+(Z2-Z1)^2) equals
>evalf(Int(Int(Int(dist*PDF(R1, t1)*PDF(R2, t2)*PDF(R3, t3), t1 = -1 .. 1), t2 = -1 .. 1), t3 = -1 .. 1));
0.6617071822
The answer in n dimensions is similar. For example, let n=4
>evalf(Int(Int(Int(Int(sqrt(t1^2+t2^2+t3^2+t4^2)* piecewise(t 1<= -1, 0, t1 <= 0, t1+1, t1 <= 1, 1-t1, 1 < t, 0) * piecewise(t2 <= -1, 0, t2<= 0, t2+1, t 2<= 1, 1-t2, 1 < t2, 0)*piecewise(t3 <= -1, 0, t3 <= 0, t3+1, t 3<= 1, 1-t3, 1 < t3, 0)*piecewise(t4 <= -1, 0, t4 <= 0, t4+1, t 4<= 1, 1-t4, 1 < t4, 0) equals
>2^4*evalf(Int(Int(Int(Int(sqrt(t1^2+t2^2+t3^2+t4^2)*(1-t4)*(1-t3)*(1-t2)*(1-t1)
,t1=0..1),t2=0..1),t3=0..1),t4=0..1)
0.7776656536