CURS V (1)

Lema.
Fie S=(b1,b2,,bk ) o secventa sortata. Atunci rank(a,S) se poate
calcula in O(1) cu O(k) procesoare.
Demonstratie.
forall I, 1 i < k, in parallel do
if bi < a bi+1 then rank i
endif
endfor
No write conflicts! Se poate si pe un EREW?

CURS V (2)
Lema.
Fie S,X,Y secvente sortate cu S=merge(X,Y) si X Y=.
Se poate calcula RankX,Y si RankY,X in O(1) cu O(card(S))
procesoare.
Dem. Pentru orice aX avem rank(a,Y)=rank(a,S) rank(a,X)
Comentarii?

CURS V (3)
Lema 1.
Fie X,Y, U secvente sortate cu U=merge(X,Y).
In plus, X este GS pentru X si Y este GS pentru Y si se stiu
RankX,X si RankY,X. Atunci se pot calcula RankX,U , RankY,U ,
RankU,X , RankU,Y in O(1) cu O(card(X)+card(Y)) procesoare.
Dem. Cum calculam RankX,U ? Fie X=(a1,a2,,ak ) cu a0 = -
si ak+1 = . Calculam:
X(i)= {x X| ai-1 < x ai }
Se poate calcula in O(1) cu O(card(X)) procesoare pentru ca stim
RankX,X
Mai mult fiecare X(i) are cel mult 3 elemente.

CURS V (4)
Demonstratie (continuare)
Calculam:
U(i)= {x Y| ai-1 < x ai }
Se poate calcula in O(1) cu O(card(X)) procesoare pentru ca stim
RankY,X .
Cate elemente are U(i)?
Calculam rangul lui x X in U astfel:
forall I, 1 i k+1, in parallel do
forall x X(i) do
compute rank (x,U(i)) (Cum?)
rank(x,U)=rank(ai-1 , U)+rank(x,U(i))
endfor
endfor
Pentru fiecare i folosim card(U(i)) procesoare

CURS V (5)
Demonstratie (continuare)
Cum calculam RankU,X ? Avem nevoie de RankX,X si RankY,X
Cum calculam RankX,X ? Pentru fiecare ai X \ X gasim
elementul minimal b din X(i+1). Avem
rank(ai , X)=rank(b, X)
deci rank(ai , X) se poate calcula in O(1) cu un singur procesor.
Pentru calculul lui rank(y , X) cu yY folosim lema anterioara
deoarece U=merge(X,Y) este deja calculat.
Concluzie: timp O(1) si O(card(U)) procesoare.

CURS V (6)
Lema
Cu notatiile din lema anterioara fie
Z=reduce(U) si Z=reduce(U)
Putem calcula RankZ,Z in O(1) cu O(card(X)+card(Y))
procesoare.
Dem. RankX,Z este calculat din RankX,U si RankY,Z din RankY,U
deci obtinem RankU,Z . Dar Z este o parte a lui Z.
Teorema: Sortarea a n numere se poate face in O(log n) pe un
CREW cu O(n) procesoare.