1. Parallaxisu za sortiranje nizova metodom potpunomesanje/ zamena.

system sortiranje; begin

const for i:=0 to 2*br-1 do
br=8; ReadInt(ulniz[i]); end;
type nizbrojeva=array[0..(2*br-1)] of integer; WriteString("Ulazni niz:");WriteLn;
configuration sort[2*br]; stampniz(ulniz);
connection ulniz:=sortiraj(0,br-1,ulniz);
mesanje:sort[i]-> {i<br} sort[2*i].mesanje, ulniz:=sortiraj(br,2*br-1,ulniz);
{i>=br} sort[(2*i+1) mod (2*br)].mesanje; WriteString("Parcijalno sortirani
inv_mesanje:sort[i]-> {even(i)} sort[(i div nizovi:");WriteLn;
2)].inv_mesanje, stampniz(ulniz);
{ odd(i)} sort[((i-1) div 2)+br].inv_mesanje; load(niz,ulniz);
zamena:sort[i]-> {even(i)} sort[i-1].zamena, parallel
{odd(i)} sort[i+1].zamena; propagate.inv_mesanje.inv_mesanje(niz);
scalar endparallel;
ulniz:nizbrojeva; store(niz,ulniz);
i,k,l:integer; WriteString("Inverzno potpuno
suslov:array [0..(2*br-1)] of boolean; mesanje:");WriteLn;
vector stampniz(ulniz);
niz:integer; ulniz:=sortiraj(0,br-1,ulniz);
uslov:boolean; ulniz:=sortiraj(br,2*br-1,ulniz);
procedure stampniz(scalar n:nizbrojeva); WriteString("Parcijalno sortiranje:");WriteLn;
scalar stampniz(ulniz);
i:cardinal; load(niz,ulniz);
begin parallel
for i:=0 to 2*br-1 do propagate.mesanje.mesanje(niz);
WriteInt(n[i],4); endparallel;
end; store(niz,ulniz);
WriteLn; WriteString("Potpuno mesanje:");WriteLn;
end stampniz; stampniz(ulniz);
procedure sortiraj(scalar i,j:cardinal;scalar for k:=0 to 2*br-1 do
n:nizbrojeva):scalar nizbrojeva; suslov[k]:=false; end;
scalar for k:=1 to br-1 do
i1,i2,found:cardinal; l:=2*k;
temp:integer; if(ulniz[l]<ulniz[l1] then
begin suslov[l]:=true;
for i1:=i to j-1 do suslov[l-1]:=true;
found:=i1; end; end;
for i2:=i1+1 to j do load(niz,ulniz);
if (n[i2]<n[found]) then load(uslov,suslov);
found:=i2; parallel
end; end; if uslov then
temp:=n[i1]; propagate.zamena.zamena(niz); end;
n[i1]:=n[found]; endparallel;
n[found]:=temp; store(niz,ulniz);
end; WriteString("Sortirani niz:");WriteLn;
return n;
end sortiraj; stampniz(ulniz);
end sortiranje.
2. parallaxisu kojim se racuna suma Tejlorovog reda funkcije u okolini tacke 0

SYSTEM Suma;
CONST n=50; STORE(polje, niz);
CONFIGURATION list [1..n]; k:=2;izlaz:=true;
CONNECTION right:list[i]->list[i+1].left; while ((k<n) and (brojpr=0) and izlaz) do
SCALAR niz:array[1..n] of real; if ((0.0<abs(niz[k])<epsilon) and (niz[k-
epsilon,x:real; 1]>epsilon))
i,j,k,brojpr: integer; then
izlaz: boolean; brojpr:=k-1;izlaz:=false;
VECTOR polje:real; end;
BEGIN k:=k+1;
X:=5; epsilon:=20; end;
brojpr:=0; niz[1]:=x; j:=j+1
for i:=2 to n do niz[i]:=0.0 end; end;
j:=1; writereal(x,2);
while ( (j <= n) and (brojpr = 0) ) do writereal(reduce.sum(polje),5);
LOAD(polje, niz); if (x=0.0) then
PARALLEL writestring("Potreban je jedan procesor za
propagate.right(polje); izracunavanje sume ");
if (id_no > 1) then else
polje:=-1.0*polje*x*x/(float((2*id_no- writestring("Koriscen broj procesora je
1)*(2*id_no-2))) ");writeint(brojpr,3)
end; end;
ENDPARALLEL; END Suma.

Paralaksisu kojim se u procesorsko polje racuna integral:

SYSTEM v1_v;
CONST
br_koraka=100; d_gr=-PI;
g_gr=Pi;
sirina=(g_gr - d_gr) / float(br_koraka);
CONFIGURATION nlist(1..br_koraka);
CONNECTION;
VECTOR povrs : real;
PROCEDURE intf( VECTOR x:real) : VECTOR real;
BEGIN
RETURN( ( x * (SIN(x)-1.0) ) / (2.0*PI) );
END intf;
BEGIN
PARALLEL
povrs:=sirina * intf( d_gr + (float(id-no)-0.5) * sirina );
ENDPARALLEL
WriteReal(REDUCE.SUM(povrs),15,9);
END v1_v;
3. Parallaxis program kojim se vrši transformacija matrice A u matricu C, kao i štampanje
matrice C, na sledeći način:

system matrica2; begin

type mat=array [1..4],[1..4] of integer; for j:=1 to 4 do
configuration matrica[4],[4]; WriteFixPt(ulmat[i,j],10,2)
connection
writeln;
smer1:matrica[i,j]-> {i=2 AND j=0}
matrica[i+1,j].smer1; end;
smer2:matrica[i,j]-> {even(i) AND j<2} load(transmat,ulmat);
matrica[i+1,j].smer2; load(pomP,pom);
{i=1 AND j<1} matrica[i+1,j+1].smer2; parallel
smer3: matrica[i,j]-> {i<3 AND j<3 AND j>0} propagate.smer1(transmat);
matrica[i,j-1].smer3; transmat=transmat*pom;
scalar ulmat:mat;
propagate.smer2(transmat);
pom:mat;
vector transmat:integer; propagate.smer3(transmat);
pomP:integer; endparallel;
begin store(transmat,ulmat);
for i:=1 to 4 do for i:=1 to 4 do
begin for j:=1 to 4 do
for j:=1 to 4 do WriteFixPt(ulmat[i,j],10,2)
pom[i,j]=13-4*i+j end; writeln;
end; end;
for i:=1 to 4 do end;
end matrica2.
4 . Parallaxis program kojim se vrši transformacija matrice A u matricu C, kao i štampanje matrice

system matrica; for j:=1 to 4 do

type WriteFixPt(ulmat[i,j],10,2)
mat=array [1..4],[1..4] of integer; writeln;
configuration matrica[4],[4]; end;
connection load(transmat,ulmat);
zamena:matrica[i,j]-> {(i=0 OR i=1) AND j=1} parallel
matrica[i,j+1].zamena, propagate.zamena(transmat);
{(i=0 OR i=1) AND j=2} matrica[i,j-1].zamena; propagate.shift(transmat);
shift:matrica[i,j]-> {even(i) AND j<3} propagate.rotate(transmat);
matrica[i+1 ,j].shift; propagate.shift2(transmat);
{i=1 AND (j=0 OR j=1)} matrica[i+1,j+1].shift; endparallel;
rotate:matrica[i,j]-> store(transmat,ulmat);
matrica[(i+j+1)MOD4,j].rotate; for i:=1 to 4 do
shift2: matrica[i,j]-> {(i=1 OR i=2) AND j<3} begin
matrica[i-1,j].shift2; for j:=1 to 4 do
scalar ulmat:mat; WriteFixPt(ulmat[i,j],10,2)
vector transmat:integer; writeln;
begin end;
for i:=1 to 4 do end;
begin end matrica.
SYSTEM Pi; for i:=0 to n-1 do
CONST n = 4; for j:= 0 to n-1 do
TYPE matrica = array[0..n-1],[0..n-1] of real; ma[i,j] := float(i*n+j + 1);
CONFIGURATION mat[0..n-1],[0..n-1]; end;
CONNECTION trans_1: mat[i,j] -> {((i=1) OR end;
(i=3)) AND ((j=1) OR(j=2))} mat[i- PARALLEL
1,j+1].trans_1, load(a,ma);
{((i=2) AND (j>0))} PROPAGATE.trans_1.trans_1(a);
mat[1,j].trans_1; PROPAGATE.trans_2.trans_2(a);
trans_2: mat[i,j] -> {((i=0) AND ((j=1) PROPAGATE.trans_3.trans_3(a);
OR (j=2)))} mat[1,j].trans_2, store(a,ma);
{((i=2) AND (j=1))} ENDPARALLEL;
mat[2,2].trans_2; for i:=0 to n-1 do
trans_3: mat[i,j] -> {(i=0)} mat[i,(j-1) for j:= 0 to n-1 do
mod 4].trans_3, Writefixpt(ma[i,j],7,2);
{(i=1)} mat[i,(j-2) mod end;
4].trans_3; WriteLn;
end;
SCALAR ma:matrica;
i:CARDINAL; END Pi.
j:CARDINAL;

VECTOR a:real;

BEGIN