def test_order_1(self): # given A = Cannon.Matrix(1, [3]) B = Cannon.Matrix(1, [4]) # when C = matrix_multiply(A, B) # then assert_that(C, is_(Cannon.Matrix(1, [12])))
def test_horizontal_shift_2x2_by_blocks_1x1(self): # given M = Cannon.Matrix(2, [1, 2, 3, 4]) # when actual = matrix_horizontal_shift(M, block_order=1) # then expected = Cannon.Matrix(2, [1, 2, 4, 3]) assert_that(actual, is_(expected))
def matrix_split(M, block_order): matriz_order = M.ncols fragments = (matriz_order / block_order) ** 2 matriz_frag = None end = True fila_matriz = 0 columna_matriz = 0 bloques = [] while end: if columna_matriz == matriz_order: columna_matriz = 0 fila_matriz += block_order if (columna_matriz % block_order) == 0: matriz_frag = Cannon.Matrix(block_order, [0] * (block_order ** 2)) bloques.append(matriz_frag) frag_col = 0 frag_fila = 0 limit=fila_matriz + block_order i=fila_matriz while i<limit: matriz_frag.data[block_order * frag_fila + frag_col] = M.data[matriz_order * i + columna_matriz] frag_fila += 1 i+=1
def matrix_add(A, B): order = A.ncols C = Cannon.Matrix(order, []) for pos in range(0, order**2): C.data.append(A.data[pos] + B.data[pos]) return C
def test_5x5_processors_200x200_operands(self): nprocs = 25 # given P = [self.broker.add_servant(ProcessorI(), Cannon.ProcessorPrx) for i in range(nprocs)] loader = self.broker.add_servant(OperationsI(P), Cannon.OperationsPrx) A_last = 200 * 200 A = Cannon.Matrix(200, range(1, 1 + A_last)) B = Cannon.Matrix(200, range(1 + A_last, 1 + A_last * 2)) # when C = loader.matrixMultiply(A, B) # then expected = matrix_multiply(A, B) assert_that(C, is_(expected))
def matrix_multiply(A, B): order = A.ncols C = Cannon.Matrix(order, []) for r in range(order): for c in range(order): cell = 0 for i in range(order): cell += A.data[(r * order) + i] * B.data[(i * order) + c] C.data.append(cell)
def __init__(self, order): self.blocks = [] self.nblocks = 0 self.g_order = order self.C = Cannon.Matrix(order, []) self.event = threading.Event() for i in range(order**2): self.blocks.append(None)
def matrix_multiply(A, B): order = A.ncols C = Cannon.Matrix(order, []) for i, j in itertools.product(xrange(order), repeat=2): C.data.append( sum(A.data[i * order + k] * B.data[k * order + j] for k in xrange(order)) ) return C
def injectFirst(self, A, step, current=None): if self.C == None: self.C = Cannon.Matrix(A.ncols, []) for i in range(A.ncols**2): self.C.data.append(0) self.p_A[step] = A if self.p_B[step] != None: self.Sum(A, self.p_B[step], step)
def matrix_vertical_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, []) for row in range(0, order): for col in range(0, order): step = block_order * int(col/block_order) retval.data.append(M.data[((row+step)%order)*order+col]) return retval
def matrix_horizontal_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, []) for row in range(0, order): for col in range(0, order): step = block_order * int(row/block_order) retval.data.append(M.data[((col+step)%order)+row*order]) return retval
def matrix_add(A, B): filsA = len(A.data) / A.ncols colsA = A.ncols filsB = len(B.data) / B.ncols colsB = B.ncols C = Cannon.Matrix(colsA, [0] * colsA * filsA) i=0 for i in range(colsA * filsA): C.data[i] = A.data[i] + B.data[i] i+=1
def matrix_multiply(A, B): order = A.ncols C = Cannon.Matrix(order, []) for row in range(0, order): for col in range(0, order): result = 0 for i in range(0, order): result += A.data[row*order+i] * B.data[i*order+col] C.data.append(result) return C
def matrix_join(*blocks): nblocks = len(blocks) block_order = blocks[0].ncols order = int(math.sqrt(nblocks)) * block_order retval = Cannon.Matrix(order, []) for row in range(0, order): for col in range(0, order): n_block = int(row/block_order) * int(order/block_order) + int(col/block_order) block_pos = row%block_order * block_order + col%block_order retval.data.append(blocks[n_block].data[block_pos]) return retval
class cliente(Ice.Application): def run(self, argv): prxFrontend = self.communicator().stringToProxy(argv[1]) frontend = Cannon.FrontendPrx.checkedCast(prxFrontend) if not frontend: raise RuntimeError("Invalid proxy frontend") A_last = 400 * 400 A400 = Cannon.Matrix(400, range(1, 1 + A_last)) B400 = Cannon.Matrix(400, range(1 + A_last, 1 + A_last * 2)) res400=frontend.multiply(A400,B400) res400dir=matrix_multiply(A400,B400) if(res400 == res400dir): print("Ok en matrix 400x400") print_matrix(res400) else: print("Error en matrix 400x400") A_last = 600 * 600
def test_vertical_shift_6x6_blocks_3x3(self): # given original = M6(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36) # when actual = matrix_vertical_shift(original, block_order=3) # then expected = M6(1, 2, 3, 22, 23, 24, 7, 8, 9, 28, 29, 30, 13, 14, 15, 34, 35, 36, 19, 20, 21, 4, 5, 6, 25, 26, 27, 10, 11, 12, 31, 32, 33, 16, 17, 18) assert_that(actual, is_(Cannon.Matrix(6, expected)))
def load_matrix_from_file(filename): with file(filename) as f: rows = f.readlines() order = len(rows[0].split()) retval = Cannon.Matrix(order, []) for row in rows: rowdata = row.split() assert len(rowdata) == order for n in rowdata: retval.data.append(float(n)) assert len(retval.data) == order ** 2 return retval
def matrix_split(M, block_order): blocks = [] order = M.ncols blocks_row = int(order / block_order) nblocks = blocks_row ** 2 for n_block in range(0, nblocks): blocks.insert(n_block, Cannon.Matrix(block_order, [])) for row in range(0, order): for col in range(0, order): n_block = int(row/block_order) * int(blocks_row) + int(col/block_order) blocks[n_block].data.append(M.data[row*order+col]) return blocks
def matrix_horizontal_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, []) for i in range(order ** 2): retval.data.append(0) for row in range(block_order): for col in range(order): retval.data[row*order + col] = M.data[row*order + col] for row in range(block_order, order): salto = int(row/block_order) for col in range(order): mov = ((col + order - salto * block_order) % order) retval.data[row * order + mov] = M.data[row * order + col] return retval
def matrix_join(blocks): nbl = int(math.sqrt(len(blocks))) block_order = blocks[0].ncols order = nbl * block_order M = Cannon.Matrix(order, []) for nveces in range(nbl): for ind_y in range(block_order): pos = ind_y * block_order block = nveces * nbl for ind_x in range(nbl): for inc in range(block_order): M.data.append(blocks[block].data[pos + inc]) block = block + 1 return M
def try_multiply(self): current_A = self.A_blocks[self.current_step] current_B = self.B_blocks[self.current_step] if current_A is None or current_B is None: return if self.current_step == 0: self.result_parcial = Cannon.Matrix(current_A.ncols, [0] * (current_A.ncols**2)) product = matrix_multiply(current_A, current_B) self.result_parcial = matrix_add(self.result_parcial, product) self.current_step += 1 if self.current_step == self.order: self.target.injectSubmatrix(self.result_parcial, self.row, self.col) return self.left.injectFirst(current_A, self.current_step) self.above.injectSecond(current_B, self.current_step) self.try_multiply()
def matrix_join(*blocks): tamano = 0 fila = 0 col = 0 matriz_order = int(math.sqrt(len(blocks) *(blocks[0].ncols ** 2))) matrix_joined = Cannon.Matrix(matriz_order, [0] * (matriz_order ** 2)) subMatrixOrder = blocks[0].ncols block_order=matriz_order / subMatrixOrder while tamano != matriz_order ** 2: if block_order == col: col = 0 fila += 1 col_aux = col * subMatrixOrder fila_aux = fila * subMatrixOrder for matrix_fila in range(subMatrixOrder): for matrix_column in range(subMatrixOrder): matrix_joined.data[(fila_aux + matrix_fila) * matriz_order + col_aux + matrix_column] = blocks[ block_order * fila + col].data[matrix_fila * subMatrixOrder + matrix_column] tamano += 1 col += 1
def gen_matrix(ini, order): return Cannon.Matrix(order, xrange(ini, ini + order ** 2))
def matrix_vertical_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, [])
def matrix_split(M, block_order): order = M.ncols blocks = [] nbl = order / block_order m = [] for ind_by in range(nbl): for ind_bx in range(nbl): pos = (ind_bx * block_order) + (ind_by * (block_order * order)) for ind_c in range(block_order): for inc in range(block_order): m.append(M.data[pos + (ind_c * order) + inc]) blocks.append(Cannon.Matrix(block_order, m)) m = [] return blocks def list_split (M, block_order): order = len(M) blocks = [] nbl = order / block_order m = [] for ind_bx in range(nbl): for inc in range(block_order): m.append(M[(ind_bx * block_order) + inc])
def M1(*data): return Cannon.Matrix(1, list(data))
def M8(*data): return Cannon.Matrix(8, list(data))
def M6(*data): return Cannon.Matrix(6, list(data))
def M4(*data): return Cannon.Matrix(4, list(data))
def matrix_add(A, B): order = A.ncols C = Cannon.Matrix(order, []) for i in range(order ** 2): C.data.append(A.data[i] + B.data[i])