#SUMA SECUENCIAL (con threading)
import math
from threading import Thread
def hilo(j,i):
if((2*i%2**j) == 0):
c[int(2*i)] = c[int(2*i)]+c[int(2*i-2**(j-1))]
c = [0,1,1,1,1,1,1,1,1]
n = len(c)
lg = int(math.log(n,2))
print c
j = 1
while(j<=lg):
i=1
while(i<=n/2):
t = Thread(target=hilo, args=(j,i))
t.start()
i = i+1
print c
j=j+1
_________________________________________________________________________
#SUMA CREW
import math
from threading import Thread
def hilo(j,i):
if((2*i % 2**j) == 0):
c[i]=c[i]+c[((i)-(int(pow(2,j-1))))];
print c
c = [24,2,11,5,32,8,15,9]
n = len(c)
lg = int(math.log(n,2))
print c
j = 1
while(j<=lg):
i=1
while(i<=n):
t = Thread(target=hilo, args=(j,i))
t.start()
t.join()
i = i+1
print c
j=j+1
_________________________________________________________________________
#Estefanía Romero.
#BUSQUEDA EREW
import math
from threading import Thread
def Broadcast(vec,a,j):
vec[1]=a
j=1
while(j<=lg):
vec[i]=vec[i-2**j-1]
j=j+1
i=i+1
def minPRAM(l):
j=1
while(j<=lg):
i=1
while(i<=(n/2**i) and i>=1):
if(l[(2**j)-1]>l[2*j]):
l[j]=l[(2**1)-1]
else:
l[j]=l[(2**j)-1]
i=i+1
j=j+1
return l[1]
def SearchPram(l,a):
Broadcast(temp,a)
j=1
while(j>=1 and j<=n):
if(l[j]==temp[j]):
temp[j]=j
else:
temp[j]=0
j=j+1
return minPRAM(temp)
#main
b=[]
temp=[]
l=[0,2,-1,23,-4,2,5,-2,5,-2,0,5,1,5,-5,8,5,3,-2]
n=len(l)
lg=int(math.log(n,2))
a=5
SearchPram(l,a)
print temp
_________________________________________________________________________
#MinCRCW
import math
from threading import Thread
def hilo1(Win,j):
Win[j]=0
def hilo2(L,Win,j,i):
if(L[j]>L[i]):
Win[j]=1
else:
Win[i]=1
def hilo3(Win,j,ind):
if(Win[j]==0):
ind[0]=j
L=[45,30,24,60]
Win=[1,1,1,1]
ind=[10000000]
j=0
n=len(L)
while(j<n):
if(j>=0):
t = Thread(target=hilo1, args = (Win,j))
t.start()
t.join()
j=j+1
j=0
i=j+1
print "PASO 1"
print "Vector original:----->", L
print Win
while(i<n):
if(j<i):
if(j>=0):
t = Thread(target=hilo2, args = (L,Win,j,i))
t.start()
t.join()
j=j+1
i=i+1
j=0
print "\nPASO 2"
print Win
while(j<n):
if(j>=0):
t = Thread(target=hilo3, args = (Win,j,ind))
t.start()
t.join()
j=j+1
print "\nPASO 3"
print "Poniendo un 0 en el valor minimo\n", Win
print " \nvalor minimo:", L[ind[0]]
_________________________________________________________________________
#Alumna: Estefanía Romero.
#Sort CRCW
import math
from threading import Thread
def hilo1(Win,j):
Win.insert(j,0)
def hilo2(Win,j,i):
if(W[j]>W[i]):
Win[j]=Win[j]+1
else:
Win[i]=Win[i]+1
def hilo3(j,Win):
W2.insert(Win[j],W[j])
W2.pop(Win[j]+1)
#main
W=[]
W2=[]
Win=[]
indexMin=[]
n=int(raw_input("Cuantos numeros deseas ingresar? : "))
j=0
while(j<n):
print "Escriba el numero de la posición ",j+1,":"
x=int(raw_input())
W.append(x)
W2.append(0)
j=j+1
n=len(W)
print "\nVector inicial: ",W
j=1
while(j<=n):
t = Thread(target=hilo1,args=(Win,j))
t.start()
t.join()
j=j+1
print "win inicial: ",Win
j=0
while(j<=n):
i=j+1
while(i<n and j<i):
t=Thread(target=hilo2, args = (Win,j,i))
t.start()
t.join()
i=i+1
j=j+1
#WIN
print "Win: ",Win
j=0
while(j<n):
t =Thread(target=hilo3,args=(j,Win))
t.start()
t.join()
j=j+1
print "Vector final: ",W2
_________________________________________________________________________
#Sort PRAM EREW Merge Secuencial
def merge_sort(array):
if len(array) == 1:
return array
else:
result = []
first_sorted = merge_sort(array[:len(array)//2])
second_sorted = merge_sort(array[len(array)//2:])
while (len(first_sorted) and len(second_sorted)):
if (first_sorted[0] <= second_sorted[0]):
result.append(first_sorted.pop(0))
else:
result.append(second_sorted.pop(0))
return result + first_sorted + second_sorted
#main
print "Ordenamiento Mergesort secuencial"
a=int(raw_input("Dame tamño del arreglo: "))
x=[]
i=0
while (i<a):
x.append(int(raw_input("Dame numero: ")))
i=i+1
b=merge_sort(x)
print "El arreglo ordenado es: ",b
_________________________________________________________________________
#Estefanía Romero.
#Sort PRAM EREW ODD-EVEN MERGE Paralelo
from threading import Thread
def OddEvenMerge(L2,ini,fin):
oddEvenMerge(L2,ini,fin)
print "procesando: ",L2[1:fin+1]
def oddEvenMerge(L2,ini,fin):
m=(fin-ini)+1
odd=[0 for _ in range((m/2)+1)]
even=[0 for _ in range((m/2)+1)]
if(m==2):
if(L2[ini]>L2[fin]):
interchange(L2,ini,fin)
else:
oddEvenSplit(L2,odd,even,ini,m)
t=Thread(target=ordena,args=(odd,(m/2)))
t.start()
t.join()
t2=Thread(target=ordena,args=(even,(m/2)))
t2.start()
t2.join()
i=1
while(i<=(m/2)):
t=Thread(target=mezclar,args=(L2,odd,even,i,1))
t.start()
t.join()
i=i+1
i=1
while(i<int(m/2)):
t=Thread(target=hiloOddEven,args=(L2,i))
t.start()
t.join()
i=i+1
i=1
while(i<=int(m/2)):
t=Thread(target=hiloOddEvenCent,args=(L2,i))
t.start()
t.join()
i=i+1
def interchange(L2,ini,fin):
aux=L2[ini]
L2[ini]=L2[fin]
L2[fin]=aux
def oddEvenSplit(L2,odd,even,ini,fin):
od=1
ev=1
x=ini
while(x<=fin):
if((x%2)==0):
even[ev]=L2[x]
ev=ev+1
else:
odd[od]=L2[x]
od=od+1
x=x+1
print "valor de odd: ",odd[1:fin+1]
print "\nvalor de even: ",even[1:fin+1]
def ordena(L2,fin):
L3=L2
num2=fin
OddEvenMerge(L3,1,num2)
def mezclar(L2,odd,even,j,aux):
m=L2
impar=odd
par=even
m[(2*j)-1]=impar[j]
m[2*j]=par[j]
def hiloOddEven(num,i):
num2=num
j=i
a=(2*j)
b=(2*j)+1
if(num2[a]>num2[b]):
interchange(num2,a,b)
def hiloOddEvenCent(num,i):
num2=num
j=i
a=(2*j)-1
b=(2*j)
if(num2[a]>num2[b]):
interchange(num2,a,b)
#main
print " ORDENAMIENTO DE LISTAS DE DIMENSION MULTIPLO DE 2"
print "\n cantidad de numeros a ordenar: "
n=int(raw_input())
while((n%2)!=0):
print "La dimension de la lista no es multiplo de 2!"
print "Ingrese una dimension valida: "
n=int(raw_input())
L=[0 for _ in range(n+1)]
i=0
while(i<n):
print "Ingrese numero ",i+1
x=int(raw_input())
L[i+1]=x
i=i+1
print "Lista de Entrada: ",L[1:n+1]
OddEvenMerge(L,1,n)
print "\nLista ordenado: ",L[1:n+1]
_________________________________________________________________________
#Multiplicacion de matrices
from threading import Thread
import math
def hilo1(j,i,l):
Z[l][j][i]=int(X[j][l])* int(Y[l][i])
def hilo2(j,i,l,k):
if(((2*l) % (2 **k))==0):
Z2[2*l][j][i]=int(Z[2*l][j][i]+Z[2*l-(2**(k))][j][i])
print " MULTIPLICACION DE MATRICES DE 2x2"
X=[[0 for _ in range(2)] for _ in range(2)]
Y=[[0 for _ in range(2)] for _ in range(2)]
Z=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
Z2=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
lg=int(math.log(2,2))
print "\n\n Matriz X:"
j=0
while(j<2):
i=0
while(i<2):
print "Valor de la posicion [",j+1 ,", ",i+1," ]: "
a=int(raw_input())
X[j][i]=a
i=i+1
j=j+1
print "\n\n Matriz Y:"
j=0
while(j<2):
i=0
while(i<2):
print "Valor de la posicion [",j+1 ,", ",i+1," ]: "
a=int(raw_input())
Y[i][j]=a
i=i+1
j=j+1
print "\nMultiplicar : \n"
print "[ ",X[0][0]," ",X[0][1]," ] X [ ",Y[0][0]," ",Y[0][1]," ]"
print "[ ",X[1][0]," ",X[1][1]," ] X [ ",Y[1][0]," ",Y[1][1]," ]"
l=0
while(l<2):
j=0
while(j<2):
i=0
while(i<2):
t=Thread(target=hilo1,args=(j,i,l))
t.start()
t.join()
i=i+1
j=j+1
l=l+1
print "\n\nPaso 1: ",Z
k=0
while(k<lg):
j=0
while(j<2):
i=0
while(i<2):
l=0
while(l<1):
t=Thread(target=hilo2,args=(j,i,l,k))
t.start()
t.join()
l=l+1
i=i+1
j=j+1
k=k+1
print "\nResultado de X X Y: \n"
print " [ ",Z2[0][0][0]," ",Z2[0][0][1]," ]"
print " [ ",Z2[0][1][0]," ",Z2[0][1][1]," ]"
Eres tremenda :D
ResponderBorrar