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 __init__(self):
self.cannon = Cannon()
self.missiles = []
self.missileVelocities = []
self.missileAccelerations = []
self.wasPressed = 0
self.initialPress = time.time()
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 loadModel(self):
self.prop = Cannon.Cannon(self.cr)
self.prop.cannonPost = self.prop
self.prop.shipId = self.shipId
self.prop.doId = self.doId
self.prop.reparentTo(self)
self.prop.loadModel(None)
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_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 createProp(self):
cannon = self.ship.cannons.get(self.cannonIndex, 0)
if cannon:
if cannon[0]:
self.prop = cannon[0]
self.ship.cannons[self.cannonIndex][1] = self
return
self.prop = Cannon.Cannon(self.cr, True)
self.ship.cannons[self.cannonIndex] = [self.prop, self]
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 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 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_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_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 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 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 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 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 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()
interface = Interface(640,695,100,600,"F.I.R.E. -MAIN_AUTO(0.1) TEST-",100) interface.build() pygame.init() ############################ GPIO.setmode(GPIO.BOARD) # BOARD!!! ############################ # Initialize the devices # motorController = MotorController(12,29,31,33,35,26,100) #ENA,IN1,IN2,IN3,IN4,ENB,Velocity(from 0 to 100) ultrasoundSensorL = UltrasoundSensor(5,3) #TRIGG,ECHO ultrasoundSensorF = UltrasoundSensor(11,7) #TRIGG,ECHO ultrasoundSensorR = UltrasoundSensor(15,13) #TRIGG,ECHO view = View(23,21) #LRServo,UDServo [servoLR = ServoMotor(23)YELLOW, servoUD = ServoMotor(21)YELLOW] tempHumL = TempHumSensor(8) #DATA tempHumR = TempHumSensor(10) #DATA irSensor = IRSensor(19) #DATA cannon = Cannon(37) webcam = WebCam() ############################ #-#-# MAIN LOOP #-#-# textMov = 'MOVING: STOP' textView = 'VIEW: CENTER' textCannon = 'CANNON: STOPPED' textTempL = '_' textTempR = '_' textDistL = '_' textDistF = '_' textDistR = '_' run = True motorController.initialize() ultrasoundSensorL.initialize()
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])
timeslice = 0.05 # How many seconds should elapse per iteration?
iterations = 288 # How many iterations should the simulation run for?
# (notice that the full journey takes 14.416 seconds, so 145 iterations will
# cover the whole thing when timeslice = 0.10)
noiselevel = 30 # How much noise should we add to the noisy measurements?
# These are arrays to store the data points we want to plot at the end.
x = []
y = []
nx = []
ny = []
vx = []
vy = []
# Let's make a cannon simulation.
c = Cannon(timeslice, noiselevel)
for i in range(iterations):
x.append(c.GetX())
y.append(c.GetY())
newestX = c.GetXWithNoise()
newestY = c.GetYWithNoise()
nx.append(newestX)
ny.append(newestY)
# Iterate the cannon simulation to the next timeslice.
c.Step()
vx.append(c.GetXVelocity())
vy.append(c.GetYVelocity())
# Plot all the results we got.
pylab.plot(x, y, '-', nx, ny, ':')
class FiringManager:
def __init__(self):
self.cannon = Cannon()
self.missiles = []
self.missileVelocities = []
self.missileAccelerations = []
self.wasPressed = 0
self.initialPress = time.time()
def displayFiringObjects(self,screen):
self.cannon.draw(screen)
for tMissile in self.missiles:
tMissile.draw(screen)
def update(self, dt):
if pygame.mouse.get_pressed()[0] == 1:
self.buttonPressed()
if pygame.mouse.get_pressed()[0] == 0:
self.buttonUnpressed()
self.doPhysics(dt)
def buttonPressed(self):
if not self.wasPressed == 1:
self.initialPress = time.time()
self.wasPressed = 1
def buttonUnpressed(self):
if self.wasPressed == 1:
timePressed = time.time() - self.initialPress
#300 N per second pressed
forceVector = self.cannon.getUnitVector() * (timePressed * 600)
tMissile = Missile()
tMissile.pos = (80, 360)
self.missiles.append(tMissile)
#2.5 kg Missiles
self.missileAccelerations.append(forceVector/2.5)
self.missileVelocities.append(Vec2d(0,0))
self.wasPressed = 0
def doPhysics(self, dt):
toRemove = []
i = 0
for tMissile in self.missiles:
tVelocity = self.missileVelocities[i]
tAcc = self.missileAccelerations[i]
tVelocity = tVelocity + (dt * tAcc)
self.missileVelocities[i] = tVelocity
tMissile.pos = (tMissile.pos[0]+(tVelocity.x * dt), tMissile.pos[1]-(tVelocity.y * dt) )
tMissile.rect.x = tMissile.pos[0]
tMissile.rect.y = tMissile.pos[1]
if not self.cannon.rect.colliderect(tMissile.rect):
#gravity
self.missileAccelerations[i] = Vec2d(0,-50)
if tMissile.pos[1] > 500:
toRemove.append((tMissile, tVelocity, tAcc))
i = i +1
for x in toRemove:
self.missiles.remove(x[0])
self.missileAccelerations.remove(x[2])
self.missileVelocities.remove(x[1])
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])
def matrix_vertical_shift(M, block_order): order = M.ncols retval = Cannon.Matrix(order, [])
def gen_matrix(ini, order):
return Cannon.Matrix(order, xrange(ini, ini + order ** 2))
