ALGORITMO 8

MULTIPLICACION DE MATRICES

#MULTIPLICACION DE MATRICES'
#OSCAR SALGADO ALAMILLA

from threading import Thread
import math
import os

#DEFINICION DE FUNCIONES
def hilo1(i,j,k):
    C[k][i][j]=int(A[i][k])* int(B[k][j])

def hilo2(i,j,k,l):
    if(((2*k) % (2 **l))==0):
        C2[2*k][i][j]=int(C[2*k][i][j]+C[2*k-(2**(l))][i][j])


#PRINCIPAL

print "======= MULTIPLICACION DE MATRICES CREW ======="


A=[[0 for _ in range(2)] for _ in range(2)]
B=[[0 for _ in range(2)] for _ in range(2)]
C=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
C2=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
   
lg=int(math.log(2,2))
print "\nLLENANDO DE LA MATRIZ A:"
i=0
while(i<2):
    j=0
    while(j<2):
       
        print "INGRESE EL VALOR DE LA POSICION [",i+1 ,", ",j+1," ]: "
        x=int(raw_input())
        A[i][j]=x
        j=j+1
    i=i+1

print "\n\nLLENANDO DE LA MATRIZ B:"
i=0
while(i<2):
    j=0
    while(j<2):
       
        print "INGRESE EL VALOR DE LA POSICION [",i+1 ,", ",j+1," ]: "
        x=int(raw_input())
        B[i][j]=x
        j=j+1
    i=i+1


print "\nPROCEDIMIENTO DE LAS MULTIPLICACIONES : \n"
print "[ ",A[0][0],"  ",A[0][1]," ]      X      [ ",B[0][0],"  ",B[0][1]," ]"
print "[ ",A[1][0],"  ",A[1][1]," ]      X      [ ",B[1][0],"  ",B[1][1]," ]"

k=0
while(k<2):
    i=0
    while(i<2):
        j=0
        while(j<2):
            t=Thread(target=hilo1,args=(i,j,k))
            t.start()
            t.join()
            j=j+1
        i=i+1
    k=k+1


print "\n\nPRIMER PROCESO: ",C

l=0
while(l<lg):
    i=0
    while(i<2):
        j=0
        while(j<2):
            k=0
            while(k<1):
                t=Thread(target=hilo2,args=(i,j,k,l))
                t.start()
                t.join()
                k=k+1
            j=j+1
        i=i+1
    l=l+1


print "\nRESULTADO DE MULTIPLICAR LAS MATRICES A Y B: \n"

print "          [ ",C2[0][0][0],"  ",C2[0][0][1]," ]"
print "          [ ",C2[0][1][0],"  ",C2[0][1][1]," ]"

os.system('pause')

ALGORITMO 7

ORDENAMIENTO EREW RECURSIVO CON MERGE SECUENCIAL

#ORDENAMIENTO EREW RECURSIVO CON MERGE SECUENCIAL
#OSCAR SALGADO ALAMILLA

import os


#DEFINICION DE FUNCIONES
def mergeSort(alist):
    print("DIVIDIENDO ",alist)
    if len(alist)>1:
        mid = len(alist)//2
        lefthalf = alist[:mid]
        righthalf = alist[mid:]

        mergeSort(lefthalf)
        mergeSort(righthalf)

        i=0
        j=0
        k=0
        while i<len(lefthalf) and j<len(righthalf):
            if lefthalf[i]<righthalf[j]:
                alist[k]=lefthalf[i]
                i=i+1
            else:
                alist[k]=righthalf[j]
                j=j+1
            k=k+1

        while i<len(lefthalf):
            alist[k]=lefthalf[i]
            i=i+1
            k=k+1

        while j<len(righthalf):
            alist[k]=righthalf[j]
            j=j+1
            k=k+1
    print("UNIENDO ",alist)


#PRINCIPAL
print "======= ORDENAMIENTO EREW RECURSIVO CON MERGE SECUENCIAL ======="
alist = []
x=int(raw_input("INGRESE EL TAMANO DEL VECTOR: "))
i=1
while (i<=x):
    n=int(raw_input("INGRESE DIGITO: "))
    alist.append(n)
    i=i+1
               
     
print 'MOSTRANDO EL VECTOR DE DIGITOS ORDENADOS: '
print(alist)

os.system('pause')

ALGORITMO 6

ORDENAMIENTO EREW RECURSIVO

#ORDENAMIENTO EREW RECURSIVO CON ODD-EVEN
#OSCAR SALGADO ALAMILLA

from threading import Thread
import os
import math


#DEFINICION DE FUNCIONES
def hilo3(L2,INI,FIN):
    oddEvenMerge(L2,INI,FIN)
    print "procesos: ",L2[1:FIN+1]
 

def OddEvenMerge(L2,INI,FIN):
    t3=Thread(target=oddEvenMerge,args=(L2,INI,FIN))
    t3.start()
    t3.join()

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]):
            intercambio(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=mezcla,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=HiloOddEvenC,args=(L2,i))
            t.start()
            t.join()
            i=i+1
     

def intercambio(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 "ODD >>>: ",odd[1:FIN+1]
    print "\nEVEN >>>: ",even[1:FIN+1]

 
def ordena(L2,FIN):
    L3=L2
    numero=FIN
    OddEvenMerge(L3,1,numero)


def mezcla(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):
    numero=num
    j=i
    a=(2*j)
    b=(2*j)+1
    if(numero[a]>numero[b]):
        intercambio(numero,a,b)

def HiloOddEvenC(num,i):
    numero=num
    j=i
    a=(2*j)-1
    b=(2*j)
    if(numero[a]>numero[b]):
        intercambio(numero,a,b)



#Programa Principal
print "========= ORDENAMIENTO EREW RECURSIVO CON ODD-EVEN ========="
print""
print "\n INGRESE TAMANO DEL VECTOR : "
print"(ATENCION: SOLO PUEDE INGRESAR NUMEROS PARES)"
n=int(raw_input())
while((n%2)!=0):
    print "EL NUMERO NO ES PAR"
    print "INGRESE UN NUMERO PAR: "
    n=int(raw_input())

L=[0 for _ in range(n+1)]
 
i=0
while(i<n):
    print "\nINGRESE VALOR ",i+1
    x=int(raw_input())
    L[i+1]=x
    i=i+1
 
print "USTED INGRESO LOS SIGUIENTES VALORES: ",L[1:n+1]
OddEvenMerge(L,1,n)

print "\nEL VECTOR ORDENADO ES: ",L[1:n+1]

os.system('pause')

ALGORITMO 5

ORDENAMIENTO CRCW

#ORDENAMIENTO CRCW
#OSCAR SALGADO ALAMILLA

from threading import Thread
import os
import math

#DEFINICION DE FUNCIONES
def hilo1(win,i):
    win.insert(i,0)


def hilo2(win,i,j):
    if(L[i]>L[j]):
        win[i]=win[i]+1
    else:
        win[j]=win[j]+1


def hilo3(i,win):
    L2.insert(win[i],L[i])
    L2.pop(win[i]+1)


#PRINCIPAL
L=[]
L2=[]
WIN=[]
indexMin=[]

print"====== O R D E N A M I E N T O  C R C W ======"



n=int(raw_input("INGRESE EL TAMAÑO DEL VECTOR: "))
i=0
while(i<n):
    print "INGRESE DIGITO ",i+1,":",
    x=int(raw_input())
    L.append(x)
    L2.append(0)
    i=i+1

n=len(L)
print "\nUSTED INGRESO LOS SIGUIENTES DIGITOS: ",L
i=1
while(i<=n):
    t=Thread(target=hilo1,args=(WIN,i))
    t.start()
    t.join()
    i=i+1
print "\nINICIALIZANDO VECTOR AUXILIAR: ",WIN
i=0

while(i<=n):
    j=i+1
    while(j<n and i<j):
        t=Thread(target=hilo2,args=(WIN,i,j))
        t.start()
        t.join()
        j=j+1 
    i=i+1

print "\nLLENANDO EL INDICE DE  WIN:  ",WIN
i=0
while(i<n):
    t=Thread(target=hilo3,args=(i,WIN))
    t.start()
    t.join()
    i=i+1
print "\nEL VECTOR ORDENADO ES: ",L2

os.system('pause')

ALGORTIMO 4

BUSQUEDA CRCW

#BUSQUEDA CRCW
#OSCAR SALGADO ALAMILLA

import os
import math
from threading import Thread

#DEFINICION DE FUNCIONES
def hilo1(Win,i):
    Win[i]=0
   
def hilo2(L,Win,i,j):
    if(L[i]>L[j]):
        Win[i]=1
    else:
        Win[j]=1
   
def hilo3(Win,i,ind):
    if(Win[i]==0):
        ind[0]=i


print"========= B U S Q U E D A   C R C W ==========="


L=[]
x=int(raw_input("INGRESE EL TAMAÑO DEL VECTOR A LLENAR: "))
i=1
while (i<=x):
    n1=int(raw_input("INGRESE DIGITO:"))
    L.append(n1)
    print L
    i+=1
Win=[1,1,1,1,1,1,1,1,1,1,1,1,1]
ind=[1000000000000000000000000]
i=0
n=len(L)

while(i<n):
    if(i>=0):
        t = Thread(target=hilo1, args = (Win,i))
        t.start()
        t.join()
    i=i+1
i=0
j=i+1

#print "PROCESO 1"
print "VECTOR ORIGINAL: >>> ", L
print Win

while(j<n):
    if(i<j):
        if(i>=0):
            t = Thread(target=hilo2, args = (L,Win,i,j))
            t.start()
            t.join()
    i=i+1
    j=j+1
i=0
#print "\nPROCESO 2"
print Win



while(i<n):
    if(i>=0):
        t = Thread(target=hilo3, args = (Win,i,ind))
        t.start()
        t.join()
        i=i+1

#print "\nPROCESO 3"
print "ENCONTRANDO EL MINIMO ELEMENTO IDENTIFICADO CON EL VALOR 0\n", Win

       
print "\nEL MINIMO VALOR ES:  ", L[ind[0]]

os.system('pause')

ALGORTIMO 3

BUSQUEDA EREW

#BUSQUEDA EREW
#OSCAR SALGADO ALAMILLA

import os
import math
from threading import Thread

#DEFINICION DE FUNCIONES
def hilo1(Temp2,i,j):
    Temp2.insert(j,Temp2[j-(2**i-1)])
   

def hilo2(K,Temp2,x,n):
    if(x<(n-1)):
        if(K[x]==Temp2[x]):
            Temp2[x]=x+1
        else:
            Temp2[x]=99999


def hilo3(Temp2,n,k):
    if(Temp2[(2**(k))-1]>Temp2[2**k]):
        Temp2[k]=Temp2[2*k]
    else:
        Temp2[k]=Temp2[(2**(k))-1]


def Broadcast(Temp,x,n):
    Temp2=[]
    Temp2=Temp
    Temp2.insert(0,numero)
    Temp2.insert(1,numero)
    i=1
    while(i<=lg):
        j=(2**(i-1))+1
        while(j<=2**i):
            t=Thread(target=hilo1,args=(Temp2,i,j))
            t.start()
            t.join()
            j=j+1
        i=i+1
       


def SearchPram(Temp,lista,n):
    i=0
    while(i<=n):
        t=Thread(target=hilo2,args=(lista,Temp,i,n))
        t.start()
        t.join()
        i=i+1


def MinPram(Temp,n):
    i=1
    while(i<=lg):
        j=1
        while(j<=int(n/(2**j))):
            t=Thread(target=hilo3,args=(Temp,n,i))
            t.start()
            t.join()
            j=j+1
        i=i+1




#PRICIPAL
print "=========  B U S Q U E D A   E R E W  =========="
a=[]
Temp=[]
lista=[]
x=int(raw_input("INGRESE EL TAMAÑO DEL VECTOR: "))
i=1
while (i<=x):
    n1=int(raw_input("INGRESE DIGITO: "))
    lista.append(n1)
    print lista
    i+=1
n=len(lista)
lg=int(math.log(n,2))

numero=int(raw_input("INGRESE EL DIGITO A BUSCAR: "))
print "========== SE OBTUVIERON LOS SIGUIENTES RESULTADOS =========="
print "------------------------------------------------------------------------"
print "NUMEROS INGRESADOS: "

print lista
Broadcast(Temp,numero,n)
print "------------------------------------------------------------------------"
print "\nVECTOR TEMPORAL: "
print Temp
SearchPram(Temp,lista,n)
print "------------------------------------------------------------------------"
print "\nINDICES:"
print Temp
MinPram(Temp,n)
h=1
while(h<len(Temp)):
    if(Temp[h]!=99999):
        pos=Temp[h]
        break
    h=h+1
print "------------------------------------------------------------------------"
print "DONDE ",numero," ESTA EN LA POSICION NUMERO: ",pos

os.system('pause')

ALGORITMO 2

SUMA CREW

#SUMA CREW
#OSCAR SALGADO

import threading
import math
import os

#DEFINICION DE HILO
def hilo(i,j):
    a[j]=a[j]+a[j-pow(2,i-1)]
    print a

#PRICIPAL
print '=====  S U M A   C R E W  ====='
a=[]
x=int(raw_input("INGRESE EL TAMAÑO DEL VECTOR: "))
i=1
while (i<=x):
    n=int(raw_input("INGRESE DIGITO: "))
    a.append(n)
    print a
    i+=1


n1=len(a)
lg=int(math.log(n1))

for i in range(1,lg):
    for j in range((pow(2,i-1)+1),n1):
        h = threading.Thread(target=hilo,args=(i,j))
        h.start()
        h.join()
        print i,j

print a
os.system('pause')