domingo, 24 de mayo de 2015

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')

martes, 17 de marzo de 2015

SUMA EREW

TAREA 7
#SUMA EREW (USO DE HILOS)
#OSCAR SALGADO ALAMILLA.

import threading
import math

#FUNCION HILO
def hilo(i,j):
    if ((2*j)%(2**i)==0):
        a[int(2*j)]=a[int(2*j)]+a[int((2*j)-2**(i-1))]
        print a
       
#PRINCIPAL
a=[0,5,2,10,1,8,12,7,3]
n=len(a)
lg=int(math.log(n,2))
print a
i=1
while(i<=lg):
    j=1
    while(j<=(n/2)):
        t=threading.Thread(target=hilo, args=(i,j, ))
        t.start()
        j=j+1

    i=i+1

jueves, 26 de febrero de 2015

TAREA 6
DEFEINICION DE PIPELINE

En informática, un pipeline o tubería es un conjunto de elementos procesadores de datos conectados en serie, en donde la salida de un elemento es la entrada del siguiente. Los elementos del pipeline son generalmente ejecutados en paralelo, en esos casos, debe haber un almacenamiento tipo buffer insertado entre elementos. Pipeline es sinónimo de segmentación.


Aplicaciones de pipelines en informática

1. Pipelines gráficos, se encuentran en la mayoría de las tarjetas gráficas, consiste en múltiples unidades aritméticas o CPUs completas, que implementan variados escenarios de operaciones típicas por ejemplo, cálculos de luz y colores, proyección de perspectiva, etc.

2. Pipelines de software o tuberías, consiste en múltiples procesos ordenados de tal forma que el flujo de salida de un proceso alimenta la entrada del siguiente proceso. Por ejemplo, los pipelines de Unix.
 


martes, 24 de febrero de 2015

TAREA 5
ALGORITMOS DE BUSQUEDA
Y
ORDENACION