def point_point_distance(p1, p2):
p1 = vector.Vector(p1)
p2 = vector.Vector(p2)
if p1 == p2:
return 0
else:
return (p2 - p1).length()
def main():
pos1 = vector.Vector(0, 0)
vel1 = vector.Vector(0, 0)
acc1 = vector.Vector(0, 0)
radius1 = 1
p1 = sized_particle.SizedParticle(pos1, vel1, acc1, radius1)
pos2 = vector.Vector(3, 3)
vel2 = vector.Vector(0, 0)
acc2 = vector.Vector(0, 0)
radius2 = 1
p2 = sized_particle.SizedParticle(pos2, vel2, acc2, radius2)
pos3 = vector.Vector(2, 0)
pos3 = vector.Vector(20, 0)
vel3 = vector.Vector(0, 0)
acc3 = vector.Vector(0, 0)
radius3 = 1
p3 = sized_particle.SizedParticle(pos3, vel3, acc3, radius3)
L = [p1, p2, p3]
result = resultant_force_by_many_points(L)
print(result)
print(result is None)
print(type(result))
print(result(p2))
def get_vertices_cannon(self):
# Calculate half of width and half of height used to simplify further processes
half_width = self.cannon_width / 2
# Some math used to rotate square around its center
point1 = vmath.Vector(-half_width, 0).rotate(self.rotation * deg2rad)
point2 = vmath.Vector(half_width, 0).rotate(self.rotation * deg2rad)
point3 = vmath.Vector(half_width, -self.cannon_length).rotate(
self.rotation * deg2rad)
point4 = vmath.Vector(-half_width, -self.cannon_length).rotate(
self.rotation * deg2rad)
# Add back our position
point1.add(self.position)
point2.add(self.position)
point3.add(self.position)
point4.add(self.position)
# Convert vectors into array of tuples (positions)
return [
point1.to_tuple(),
point2.to_tuple(),
point3.to_tuple(),
point4.to_tuple()
]
def _main():
earth = Body(vector.Vector([5, 5]), vector.Vector([0, 1]), 12)
print(earth._r[0])
stddraw.setXscale(0, 10)
stddraw.setYscale(0, 10)
earth.draw()
stddraw.show()
def update(self):
key_pressed = pygame.key.get_pressed()
if key_pressed[self.key_tuple[1]]:
self.force.y = self.movement_force
elif key_pressed[self.key_tuple[0]]:
self.force.y = -self.movement_force
else:
self.force.y = 0
if key_pressed[self.key_tuple[3]]:
self.add_rotation(-self.turn_torque * delta_time)
elif key_pressed[self.key_tuple[2]]:
self.add_rotation(self.turn_torque * delta_time)
self.force.add(self.velocity.get_normalized().multiply(
vmath.Vector(self.mass * gravity_coefficient *
friction_coefficient)))
self.acceleration = self.force.divide_new(vmath.Vector(self.mass))
self.velocity.add(self.acceleration.multiply(vmath.Vector(delta_time)))
if self.velocity.get_magnitude() > self.max_velocity:
self.velocity = self.velocity.get_normalized().multiply(
vmath.Vector(self.max_velocity))
self.position.add(
self.velocity.multiply_new(vmath.Vector(delta_time)).rotate(
self.rotation * deg2rad))
self.draw()
def window_ray(self, x, y):
"""
return a ray that goes through the given pixel-coordinate,
in camera-space. NOT normalized.
return: start, direction (vectors. world-space coordinates)
("start" is necessary in case of orthogonal projection)
"""
if self.mode == self.ORTHOGONAL:
# TODO: untested
xx = self.orthox * (float(x) / self.w_pixels - .5)
yy = self.orthoy * (float(y) / self.h_pixels - .5)
return vector.Vector((xx, -yy, 0.)), vector.Vector((0., 0., 1.))
elif self.mode == self.PERSPECTIVE:
w, h = self.w_pixels, self.h_pixels
# TODO: aspect ratio.. or already in tanfov*?
xx = x - w / 2.
yy = (y - h / 2.) * w / h * self._tanfovy_2 / self._tanfovx_2
zz = w / 2. / self._tanfovx_2
return vector.Vector(), vector.Vector((xx, -yy, zz))
return None, None
def move(self):
moveVector = self.wander()
if (self._fullCounter > 0):
moveVector = self.wander()
self._fullCounter -= 1
elif (self.findClosestPreyNeighbor() != None):
moveVector = self.hunt()
else:
moveVector = self.wander()
self._wanderCounter += 1
originalVector = vector.Vector(self.getx(), self.gety())
moveVector.scale(PREDATOR_SPEED)
finalVector = moveVector + originalVector
finalVectorDirection = vector.Vector(
finalVector._x - originalVector._x,
finalVector._y - originalVector._y)
heading = self._turtle.heading()
#heading 0 is east and 90 is north while atan2 returns 0 as north
#and 90 and east, so i convert heading to atan2 degrees
originalVectorDirection = vector.Vector(
math.cos(math.radians(heading)), math.sin(math.radians(heading)))
#uses atan2 to find the finalvector heading
newAngle = (math.degrees(
math.atan2(finalVectorDirection._x, finalVectorDirection._y)) -
(math.degrees(
math.atan2(originalVectorDirection._x,
originalVectorDirection._y))))
newAngle = self._angle - newAngle
self._angle = newAngle
self._turtle.setheading(self._angle)
if (finalVector._x >= self._world.gety() or finalVector._x <= 0
or finalVector._y >= self._world.gety()
or finalVector._y <= 0):
self._angle = (self._angle + 180) % 360
self._turtle.setheading(self._angle)
self._turtle.goto(finalVector._x, finalVector._y)
del self._world._agents[self.getx(), self.gety()]
self._x = self._turtle.xcor()
self._y = self._turtle.ycor()
self._world._agents[self.getx(), self.gety()] = self
if (self._starvationCounter >= PREDATOR_STARVATION):
position = (self.getx(), self.gety())
self._world._agents[position]._turtle.hideturtle()
del self._world._agents[position]._turtle
del self._world._agents[position]
if (self._birthCounter >= PREDATOR_BIRTH):
predator = Predator(self._world,
self.getx() - 5.1,
self.gety() - 5.1)
self._birthCounter = 0
self._starvationCounter += 1
self._birthCounter += 1
def VecPlusSubMul():
print("###################################################")
addRes = vec.Vector([8.218, -9.341]) + vec.Vector([-1.129, 2.111])
print("Add result = {}".format(addRes))
subRes = vec.Vector([7.119, 8.215]) - vec.Vector([-8.223, 0.878])
print("Sub result = {}".format(subRes))
mulRes = vec.Vector([1.671, -1.012, -0.318]) * 7.41
print("Mul result = {}".format(mulRes))
def right_angle(v1, v2):
x = vector.Vector(v1[0], v1[1])
y = vector.Vector(v2[0], v2[1])
dot = vector.dot(x, y)
_angle = math.acos(dot / x.length() / y.length())
if x[0] * y[1] < y[0] * x[1]:
_angle = 2 * math.pi - _angle
return _angle
def __init__(self,mag=10):
super(Origin,self).__init__()
x_vector = vector.Vector(tail=[0,0,0],head=[mag,0,0],color=[1,0,0])
y_vector = vector.Vector(tail=[0,0,0],head=[0,mag,0],color=[0,1,0])
z_vector = vector.Vector(tail=[0,0,0],head=[0,0,mag],color=[0,0,1])
origin_point = fso.Sphere(r=mag/20)
origin_point.set_color([1,1,0])
self.add_obj([origin_point,x_vector,y_vector,z_vector])
def walls_collision(sz_particle: sized_particle.SizedParticle, width, height):
x, y = sz_particle.get_pos().coords()
vx, vy = sz_particle.get_vel().coords()
radius = sz_particle.get_radius()
if x <= radius: return vector.Vector(0, 1)
if x >= width - radius: return vector.Vector(0, -1)
if y <= radius: return vector.Vector(-1, 0)
if y >= height - radius: return vector.Vector(1, 0)
def test_ReLU_backward(self):
w = vector.Vector([2.5, 1.5, -0.5])
res = vector.ReLU_backward(self.v, w)
self.assertIsInstance(res, vector.Vector)
assert_allclose(self, res, vector.Vector([-0.5, 1.5, 0.0]))
with self.assertRaises(ValueError):
vector.ReLU_backward(self.v, vector.Vector([1.0]))
def test_add(self):
w = vector.Vector([0.5, -0.5, -1.5])
s = self.v + w
self.assertIsInstance(s, vector.Vector)
assert_allclose(self, self.v + w, vector.Vector([1.0, 1.0, 1.0]))
with self.assertRaises(ValueError):
self.v + vector.Vector([1.0])
def main():
vetor1 = vector.Vector([8.218,-9.341])
print(vetor1.plus(vector.Vector([-1.129,2.111])))
vetor2 = vector.Vector([7.119,8.215])
print(vetor2.minus(vector.Vector([-8.223,0.878])))
vetor3 = vector.Vector([1.671,-1.012,-0.318])
print(vetor3.times_scalar(7.41))
def collision(self, paddle_pos, target_point, stamina):
v = [target_point[0] - paddle_pos[0], target_point[1] - paddle_pos[1]]
mag_v = (v[0] ** 2 + v[1] ** 2) ** (1 / 2)
unit_v = [v[0] / mag_v, v[1] / mag_v]
unit_perp = vector.Vector(-unit_v[1], unit_v[0])
dir_to_ball = vector.Vector(self.position[0] - paddle_pos[0], self.position[1] - paddle_pos[1])
d = self.dot(dir_to_ball, vector.Vector(unit_v[0], unit_v[1]))
e = self.dot(dir_to_ball, unit_perp)
if not pygame.key.get_pressed()[pygame.K_SPACE]:
self.end = False
self.stay = False
if pygame.Rect(self.position[0], self.position[1], 10, 10).colliderect(
pygame.Rect(paddle_pos[0] - (stamina / 2), paddle_pos[1] - 5, stamina, 10)):
if unit_v[1] > 0:
if unit_v[0] >= 0:
self.direction = [1, -1]
if unit_v[0] <= 0:
self.direction = [-1, -1]
if self.current_powerup == "Heavy":
self.bounce = self.bounce + 1
else:
self.direction = unit_v
if self.current_powerup == "Heavy":
self.bounce = self.bounce + 1
elif pygame.key.get_pressed()[pygame.K_SPACE]:
self.end = False
self.stay = False
if not (abs(d) > 15 or abs(e) > int(stamina)):
if unit_v[1] > 0:
if unit_v[0] >= 0:
self.direction = [1, -1]
if unit_v[0] <= 0:
self.direction = [-1, -1]
if self.current_powerup == "Heavy":
self.bounce = self.bounce + 1
else:
self.direction = unit_v
if self.current_powerup == "Heavy":
self.bounce = self.bounce + 1
if self.position[0] <= 0:
self.position[0] = 0
self.direction = [-1 * self.direction[0], self.direction[1]]
if self.position[0] + 10 >= self.win.get_width():
self.position[0] = self.win.get_width() - 10
self.direction = [-1 * self.direction[0], self.direction[1]]
if self.position[1] <= 0:
self.position[1] = 0
self.direction = [self.direction[0], -1 * self.direction[1]]
if self.position[1] + 10 >= self.win.get_height():
# self.position[1] = self.win.get_height() - 10
# self.direction = [self.direction[0], -1 * self.direction[1]]
self.life_lost += 1
self.position = paddle_pos
def fillBlocks(self): ### blocks import vector import block self.blocks.append(block.Block(vector.Vector(0.0, 1.75), 1.0, 3.5)) self.blocks.append(block.Block(vector.Vector(self.field_width / 2.0 + 0.25, self.field_height / 2.0 - 0.5), 0.5, self.field_height + 1.0)) self.blocks.append(block.Block(vector.Vector(-self.field_width / 2.0 - 0.25, self.field_height / 2.0 - 0.5), 0.5, self.field_height + 1.0)) self.blocks.append(block.Block(vector.Vector(0.0, -0.5), self.field_width, 1.0)) self.blocks.append(block.Block(vector.Vector(0.0, self.field_height - 0.25), self.field_width, 0.5))
def __init__(self):
self.rEarth = vector.Vector(1,0,0)
self.vEarth = vector.Vector(0,2*math.pi,0)
self.rMars = vector.Vector(1.5,0,0)
self.vMars = vector.Vector(0,2*math.pi/math.sqrt(1.5),0)
self.max_steps = 10000
self. solver = Solver.RK4(0.01)
self.physics = Physics.CentralGravity(self.solver,G=4*math.pi**2,M=1)
def __init__(self, game):
pg.sprite.Sprite.__init__(self)
self.game = game
self.image = pg.Surface((30, 40))
self.image.fill(YELLOW)
self.rect = self.image.get_rect()
self.rect.center = (WIDTH / 2, HEIGHT / 2)
self.pos = vec.Vector(WIDTH / 2, HEIGHT / 2)
self.vel = vec.Vector(0, 0)
self.acc = vec.Vector(0, 0)
def move(self):
moveVector = self.wander()
if (self.findClosestPredatorNeighbor() != None):
moveVector = self.flee()
else:
self._wanderCounter += 1
moveVector = self.wander()
originalVector = vector.Vector(self.getx(), self.gety())
moveVector.scale(PREY_SPEED)
finalVector = moveVector + originalVector
finalVectorDirection = vector.Vector(
finalVector._x - originalVector._x,
finalVector._y - originalVector._y)
heading = self._turtle.heading()
originalVectorDirection = vector.Vector(
math.cos(math.radians(heading)), math.sin(math.radians(heading)))
newAngle = (math.degrees(
math.atan2(finalVectorDirection._x, finalVectorDirection._y)) -
(math.degrees(
math.atan2(originalVectorDirection._x,
originalVectorDirection._y))))
newAngle = self._angle - newAngle
self._angle = newAngle
self._turtle.setheading(self._angle)
if (finalVector._x >= self._world.gety() or finalVector._x <= 0
or finalVector._y >= self._world.gety()
or finalVector._y <= 0):
self._angle = (self._angle + 180) % 360
self._turtle.setheading(self._angle)
if finalVector._x >= self._world.gety():
finalVector.set((2 * self._world.getx()) - finalVector._x,
finalVector._y)
if finalVector._x <= 0:
finalVector.set(abs(finalVector._x), finalVector._y)
if finalVector._y >= self._world.gety():
finalVector.set(finalVector._x,
(2 * self._world.gety()) - finalVector._y)
if finalVector._y <= 0:
finalVector.set(finalVector._x, abs(finalVector._y))
self._turtle.goto(finalVector._x, finalVector._y)
del self._world._agents[self.getx(), self.gety()]
self._x = self._turtle.xcor()
self._y = self._turtle.ycor()
self._world._agents[self.getx(), self.gety()] = self
if (self._birthCounter >= PREY_BIRTH):
prey = Prey(self._world, self.getx() - 5.2, self.gety() - 5.2)
self._birthCounter = 0
self._birthCounter += 1
def getBasePoint(self):
v = self.normalVector.data
a = v[0]
b = v[1]
if a == 0:
return vector.Vector([0, self.constant / b],
self.normalVector.tolerance)
else:
return vector.Vector([self.constant / a, 0],
self.normalVector.tolerance)
def error_2(self,v0):
vShip = vector.Vector(0,v0,0)
rShip = vector.Vector(1,0,0)
Ship = Body.GravBody(1,rShip,vShip)
sim = Simulation.OrbitSim(self.stop_1,self.physics,Ship)
sim.advance()
time, Ships = sim.get_results()
r = [[s.position.r for s in ship] for ship in Ships]
max_r = max(r)
error = max_r[0] - 1.5 #since r becomes another stupid list of lists
return error
def activate(self):
fact = 1000
if (self.clock_time / fact) % 4 != 0:
self.insert_flag = 0
if (self.clock_time / fact) % 4 == 0:
if self.insert_flag == 0:
v1=vector.Vector((20, 200))
v2=vector.Vector((2.8, 0))
self.insert_flag = 1
self.barrels.append(BlueBarrel(v1,v2, v2, globals.bluebarrel_sideways_an, 1))
def separated_by_axis(vertices, bnds, axis):
d = 0
for i in range(3):
v = vector.Vector(0,0,0)
a,b = bnds[i]
v[i] = (b-a)/2
d += abs(v * axis)
bnds_center = vector.Vector(map(sum, bnds)) * 0.5
projected = map(lambda v: (v - bnds_center) * axis, vertices)
return min(projected) > d or max(projected) < -d
def error(theta):
htarg = 0
r = vector.Vector(0,0,0)
v = vector.Vector(r=100,theta=theta,phi=(math.pi/2))
particle = Body.GravBody(5,r,v)
solver =Solver.RK4(0.1)
physics = Physics.UniformGravity(solver,c=0.1)
sim = Simulation.TrajectorySim(stop_maker(htarg),physics,particle)
a,b = sim.get_results()
y = [p.position.y for p in b]
E = particle.position.x - max(y)
return E
def estimate_pose():
random_position_gen()
global estimated_pose
# Upper left corner
position_arr = [estimated_pose]
# Upper right corner
position_arr.append(vector.Vector(position_arr[0].x + 10, position_arr[0].y))
# Lower left corner
position_arr.append(vector.Vector(position_arr[0].x, position_arr[0].y - 10))
# Lower right corner
position_arr.append(vector.Vector(position_arr[0].x - 10, position_arr[0].y - 10))
return create_message(position_arr)
def reset(self, position, standing):
if standing:
rectangle = self.standing_rectangle #works cuz implicit
height = self.width * 2
else:
rectangle = self.crouched_rectangle
height = self.width
rectangle.points[0] = position + vector.Vector(self.width / -2, 0)
rectangle.points[1] = position + vector.Vector(self.width / 2, 0)
rectangle.points[2] = position + vector.Vector(self.width / 2, -1 * height)
rectangle.points[3] = position + vector.Vector(self.width / -2, -1 * height)
def Task3():
print("###################################################")
v1 = vec.Vector([-0.221, 7.437])
v2 = vec.Vector([8.813, -1.331, -6.247])
v3 = vec.Vector([5.581, -2.136])
v4 = vec.Vector([1.996, 3.108, -4.554])
print(v1.Magnitude())
print(v2.Magnitude())
v3.Normalize()
v4.Normalize()
print("v3 Normalized = {}".format(v3))
print("v4 Normalized = {}".format(v4))
def sim_3(self):
r1 = vector.Vector(1., 0, 0)
v1 = vector.Vector(0, 1.1 * math.pi, 0)
r2 = vector.Vector(-1., 0, 0)
v2 = vector.Vector(0, -1.1 * math.pi, 0)
One = Body.GravBody(1., r1, v1)
Two = Body.GravBody(1., r2, v2)
Objects = [One, Two]
sim = Simulation.OrbitSim(physics=self.physics, body=Objects)
sim.advance(time=10.)
time, bodies = sim.get_results()
self.plorbits(bodies)
def testcase1():
print('#' * 20)
print('performing arithmetic operations on vectors')
print('#' * 20)
vec1 = v.Vector([8.218, -9.341])
vec2 = v.Vector([-1.129, 2.111])
vec3 = v.Vector([7.119, 8.215])
vec4 = v.Vector([-8.223, 0.878])
vec5 = v.Vector([1.671, -1.012, -0.318])
print(vec1 + vec2)
print(vec3 - vec4)
print(vec5 * 7.41)
print('#' * 20)
def test_normalize3(self):
# pdb.set_trace()
v1 = v.Vector([-1, 1, 1])
v1_normalized = v1.normalize()
sqrt3 = round(math.sqrt(3), 3)
expected_vector = v.Vector(
[round(-1 / sqrt3, 3),
round(1 / sqrt3, 3),
round(1 / sqrt3, 3)])
self.assertEqual(
v1_normalized, expected_vector,
"vector {} != {}".format(str(v1_normalized), str(expected_vector)))
