Are functions called in parfor independent from each other

Hello everyone!

I have a question about using parfor loop related to my statistics test. I am trying to split my test from one that has 1000 iterations to four parallel tests that have 250 iterations to save time. Am I right saying that there is no influence between workers involved in this and the test result will correspond regular 1000 iteration test? The program has no errors

Script text:

S = 250;
D = zeros(4,1);
F = zeros(4,1);
d = 4;
parfor e = 1:d
    [D(e,1),F(e,1)] = MonteCarlo(S);
end

Unrecognized function or variable 'MonteCarlo'.

disp('D = ');
disp((D(1,1)+D(2,1)+D(3,1)+D(4,1))/(d*S));
disp('F=');
disp((F(1,1)+F(2,1)+F(3,1)+F(4,1))/(d*S));

[Torsten]

Since we don't know the meaning of your output from MonteCarlo, we cannot say whether the D and F you obtain with one call of 1000 samples can be compared to D(1,1)+D(2,1)+D(3,1)+D(4,1) and F(1,1)+F(2,1)+F(3,1)+F(4,1) with 4 calls of 250 samples.

[Arkadiy]

Sure, here it is!

function [D,F] = MonteCarlo(S)
D=0;
F=0;
for U = 1:S
    SNRdB = 6;
    SNR = 10.^(0.1*SNRdB);
    sigma = 1;
    Amp = sqrt(SNR)*sigma*sqrt(2);
    mu = Amp;
    Nx = 20;
    Ny = 20;
    K = 10;
    Z = zeros(Nx,Ny,K);
    L = zeros(Nx,Ny,K);
    T=1;
    Vmin = 0.5;
    Vmax = 1.5;
    theta = 0;
    rho = 0;
    dth = 0.035;
    drh = 0.06;
    Nt = 180;
    Nr = 334;
    List = zeros(Nt+1,Nr+1);
    threshold1 = 7.5;
    threshold2 = 6;
    X = zeros(Nx,K,Nt+1,Nr+1);
    Y = zeros(Ny,K,Nt+1,Nr+1);
    mmax = 1;
    nmax = 1;
    M = zeros(Nt+1,1);
    N = zeros(Nr+1,1);
    Proof = zeros(Nx,Nx,Ny,Ny,K,K);
    for m = 1:Nt+1
        M(m,1) = (3.1415/Nt)*(m-Nt/2-1);
    end
    for n = 1:Nr+1
        N(n,1) = 2*Nx*(n-Nr/2-1)/Nr;
    end
    for i = 1:K
        Z(:,:,i) = exprnd(2*((sigma)).^2,Nx,Ny);
    end
    for i = 1:K
        Norm1 = normrnd(mu/(sqrt(2)),sigma);
        Norm2 = normrnd(mu/(sqrt(2)),sigma);
        L(i,Ny-i,i) = (Norm1.^2+Norm2.^2);
        Z(i,Ny-i,i) = L(i,Ny-i,i);
    end
    for i = 1:Nx
        for j = 1:Ny
            for k = 1:K
                if Z(i,j,k) < threshold1
                    Z(i,j,k) = 0;
                end
            end
        end
    end
    for c = 1:Nx*Ny*K*500
        k1 = randi(K);
        k2 = randi(K);
        i1 = randi(Nx);
        i2 = randi(Nx);
        j1 = randi(Ny);
        j2 = randi(Ny);
        if Proof(i1,i2,j1,j2,k1,k2) == 0 && k1 ~= k2
            if (Vmin <= (sqrt((i1-i2)^2+(j1-j2)^2)/(abs(k1-k2)*T))) && ((sqrt((i1-i2)^2+(j1-j2)^2)/(abs(k1-k2)*T)) <= Vmax) && (Z(i1,j1,k1) ~=0) && (Z(i2,j2,k2) ~=0)
                theta = atan(-1*(i1-i2)/(j1-j2));
                rho = i1*cos(theta)+j1*sin(theta);
                mindist = 1;
                mmin = 1;
                nmin = 1;
                for m = 1:Nt+1
                    for n = 1:Nr+1
                        if (abs(M(m) - theta) < dth) && (abs(N(n) - rho) < drh) && sqrt((M(m)-theta).^2+(N(n)-rho).^2) < mindist
                            mindist = sqrt((M(m)-theta).^2+(N(n)-rho).^2);
                            mmin = m;
                            nmin = n;
                        end
                    end
                end
                if mindist < 1
                    if  X(i1,k1,mmin,nmin) == 0 && Y(j1,k1,mmin,nmin) == 0
                        X(i1,k1,mmin,nmin) = 1;
                        Y(j1,k1,mmin,nmin) = 1;
                        List(mmin,nmin) = List(mmin,nmin) + 1;
                    end
                    if X(i2,k2,mmin,nmin) == 0 && Y(j2,k2,mmin,nmin) == 0
                        X(i2,k2,mmin,nmin) = 1;
                        Y(j2,k2,mmin,nmin) = 1;
                        List(mmin,nmin) = List(mmin,nmin) + 1;
                    end
                    M(mmin) = (M(mmin)+theta)/2;
                    N(nmin) = (N(nmin)+rho)/2;
                end
            end
            Proof(i1,i2,j1,j2,k1,k2) = Proof(i1,i2,j1,j2,k1,k2)+1;
        end
    end
    MAXIMUM = 0;
    for m = 1:Nt+1
        for n = 1:Nr+1
            if (List(m,n) > MAXIMUM) && (List(m,n) > threshold2)
                MAXIMUM = List(m,n);
                nmax = n;
                mmax = m;
            end
        end
    end
    if MAXIMUM > threshold2
        F = F + 1;
    end
    theta_real = atan(-1*(1-10)/(19-10));
    rho_real = 1*cos(atan(-1*(1-10)/(19-10)))+19*sin(atan(-1*(1-10)/(19-10)));
    if abs(theta_real - M(mmax)) < 0.05 && abs(rho_real - N(nmax)) < 0.5 && MAXIMUM > threshold2
        D = D + 1;
    end
end
end

[Torsten]

Again, I don't know what you do in your function.

These two applications would be equivalent:

rng("default")
x1 = rand(1000,1);
xmean = mean(x1)

xmean = 0.4888

and

rng("default")
parfor i = 1:4
    x2(i,:) = rand(250,1);
end
x2 = x2(:);
mean(x2)

ans = 0.4888

But I don't know if it's as simple as here in your application.

[Arkadiy]

My function implements a type of Hough Transform which makes detection of a trajectory with noise background. I just doubt, whether varibales from one of four "workers" or "process" (sorry, I don't speak terms) are common, or for each parallel there are created their own local variables?

[Torsten]

The processes are independent, even with the random number generation:

https://uk.mathworks.com/help/parallel-computing/repeat-random-numbers-in-parfor-loops.html

[Matt J]

These two applications would be equivalent:

They would be equivalent statistically, but note that they would not produce the same stream of random numbers, even though the generator is reset:

rng("default")
x1 = rand(1000,1);


rng("default")
parfor i = 1:4
    x2(:,i) = rand(250,1);
end
x2 = x2(:);

[low,high]=bounds(x1-x2)

low = -0.9986

high = 0.9986

[Torsten]

These two applications would be equivalent:

I meant statistically equivalent to estimate the mean of a uniformly distributed random variable by the use of 1000 realizations. Sorry for the confusion.

Answer 1

[Walter Roberson]

No, there will be a difference.

Linear for loop uses a single random number stream (unless you deliberately change this.)

parfor iterations operate on separate random streams for each iteration.

So for example linear for loop of 1000 iterations might start with seed 3128931 and iterate over that stream. But parfor 1:4 might run the first iteration starting with seed 7488, and the second iteration with seed 574752455, and the third iteration with seed 219, and the fourth iteration with seed 875621642315.

It follows that although the results are statistically the same as each other, that they will not be actually the same as each other.