Brian Fisher wrote:
> so I wrote test functions to take a 2d position, subtract another
> position from it then multiply the result by a scalar (basically pan
> and zoom a position). One version uses the 2d vector with operator
> overloading, so it will allocate 2 vec2d's, each with a list member.
> Another version does explicit math operations on variables, so no
> allocations happen. I also tried converting the vec2d class to be
> inherited from tuple, thinking that maybe you could save the list
> member allocations by being a tuple to start with...
When I said "explicitly storing two variables", I meant doing more
like the following:
class Vector2D(object):
def __init__(self, dx, dy):
object.__init__(self)
self.dx = dx
self.dy = dy
def __sub__(self, v2):
return Vector(self.dx - v2.dx, self.dy - v2.dy)
def __add__(self, v2):
return Vector(self.dx + v2.dx, self.dy + v2.dy)
def __iadd__(self, v2):
self.dx = self.dx + v2.dx
self.dy = self.dy + v2.dy
return self
def __isub__(self, v2):
self.dx = self.dx - v2.dx
self.dy = self.dy - v2.dy
return self
This is the Vector class I use. I did tests with this approach and, as
you might expect, it's also much slower than just using two variables
outside of a class. I'm attaching the modified benchmarking script.
> like a 48:1 performance diff. Also the tuple inherited version was
> slower.
This is good information but really astonishing. The next step would
probably be benchmarking just to confirm that the large number of
calls to __init__ and __new__ are what are causing the slowdown. It
could also be that method calls are much slower than no function
calls. It certainly isn't clear how best to take advantage of this
speedup without going crazy from pos_x and pos_y variables all over
the place. Maybe unpacking the vectors in certain parts of the code
would be sufficient to speed things up, or maybe converting certain
operations to in-place vector modifications would be good enough.
Ethan
"""
2D Vector Math Class (with operator overload goodness)
(C) Copyright 2005 James Paige and Hamster Republic Productions
"""
########################################################################
import operator
import math
########################################################################
class vec2d(object):
def __init__(self, x_or_pair, y = None):
if y == None:
try:
self.vec = [x_or_pair[0],x_or_pair[1]]
except TypeError:
raise TypeError("vec2d constructor requires a tuple or two arguments")
else:
self.vec = [x_or_pair,y]
def get_x(self):
return self.vec[0]
def set_x(self, value):
self.vec[0] = value
x = property(get_x, set_x)
def get_y(self):
return self.vec[1]
def set_y(self, value):
self.vec[1] = value
y = property(get_y, set_y)
def set(self, x, y):
self.vec[0] = x
self.vec[1] = y
# String representaion (for debugging)
def __repr__(self):
return 'vec2d(%s, %s)' % (self.x, self.y)
# Array-style access
def __len__(self): return 2
def __getitem__(self, key):
return self.vec[key]
def __setitem__(self, key, value):
self.vec[key] = value
# Comparison
def __eq__(self, other):
return self.vec[0] == other[0] and self.vec[1] == other[1]
def __ne__(self, other):
return self.vec[0] != other[0] or self.vec[1] != other[1]
def __nonzero__(self):
return self.vec[0] or self.vec[1]
# Generic operator handlers
def _o2(self, other, f):
"Any two-operator operation where the left operand is a vec2d"
try:
return vec2d(f(self.vec[0], other[0]),
f(self.vec[1], other[1]))
except TypeError:
return vec2d(f(self.vec[0], other),
f(self.vec[1], other))
def _r_o2(self, other, f):
"Any two-operator operation where the right operand is a vec2d"
try:
return vec2d(f(other[0], self.vec[0]),
f(other[1], self.vec[1]))
except TypeError:
return vec2d(f(other, self.vec[0]),
f(other, self.vec[1]))
def _o1(self, f):
"Any unary operation on a vec2d"
return vec2d(f(self.vec[0]), f(self.vec[1]))
# Addition
def __add__(self, other):
return self._o2(other, operator.add)
__radd__ = __add__
# Subtraction
def __sub__(self, other):
return self._o2(other, operator.sub)
def __rsub__(self, other):
return self._r_o2(other, operator.sub)
# Multiplication
def __mul__(self, other):
return self._o2(other, operator.mul)
__rmul__ = __mul__
# Division
def __div__(self, other):
return self._o2(other, operator.div)
def __rdiv__(self, other):
return self._r_o2(other, operator.div)
def __floordiv__(self, other):
return self._o2(other, operator.floordiv)
def __rfloordiv__(self, other):
return self._r_o2(other, operator.floordiv)
def __truediv__(self, other):
return self._o2(other, operator.truediv)
def __rtruediv__(self, other):
return self._r_o2(other, operator.truediv)
# Modulo
def __mod__(self, other):
return self._o2(other, operator.mod)
def __rmod__(self, other):
return self._r_o2(other, operator.mod)
def __divmod__(self, other):
return self._o2(other, operator.divmod)
def __rdivmod__(self, other):
return self._r_o2(other, operator.divmod)
# Exponentation
def __pow__(self, other):
return self._o2(other, operator.pow)
def __rpow__(self, other):
return self._r_o2(other, operator.pow)
# Bitwise operators
def __lshift__(self, other):
return self._o2(other, operator.lshift)
def __rlshift__(self, other):
return self._r_o2(other, operator.lshift)
def __rshift__(self, other):
return self._o2(other, operator.rshift)
def __rrshift__(self, other):
return self._r_o2(other, operator.rshift)
def __and__(self, other):
return self._o2(other, operator.and_)
__rand__ = __and__
def __or__(self, other):
return self._o2(other, operator.or_)
__ror__ = __or__
def __xor__(self, other):
return self._o2(other, operator.xor)
__rxor__ = __xor__
# Unary operations
def __neg__(self):
return self._o1(operator.neg)
def __pos__(self):
return self._o1(operator.pos)
def __abs__(self):
return self._o1(operator.abs)
def __invert__(self):
return self._o1(operator.invert)
# vectory functions
def get_length_sqrd(self):
return self.vec[0]**2 + self.vec[1]**2
def get_length(self):
return math.sqrt(self.vec[0]**2 + self.vec[1]**2)
def __setlength(self, value):
self.normalize_return_length()
self.vec[0] *= value
self.vec[1] *= value
length = property(get_length, __setlength, None, "gets or sets the magnitude of the vector")
def rotate(self, angle_degrees):
radians = math.radians(angle_degrees)
cos = math.cos(radians)
sin = math.sin(radians)
x = self.vec[0]*cos - self.vec[1]*sin
y = self.vec[0]*sin + self.vec[1]*cos
self.vec[0] = x
self.vec[1] = y
def get_angle(self):
if (self.get_length_sqrd() == 0):
return 0
return math.degrees(math.atan2(self.vec[1], self.vec[0]))
def get_angle_between(self, other):
cross = self.vec[0]*other[1] - self.vec[1]*other[0]
dot = self.vec[0]*other[0] + self.vec[1]*other[1]
return math.degrees(math.atan2(cross, dot))
def __setangle(self, angle_degrees):
self.vec[0] = self.length
self.vec[1] = 0
self.rotate(angle_degrees)
angle = property(get_angle, __setangle, None, "gets or sets the angle of a vector")
def normalized(self):
length = self.length
if length != 0:
return self/length
return vec2d(self)
def perpendicular(self):
return vec2d(-self.vec[1], self.vec[0])
def perpendicular_normal(self):
length = self.length
if length != 0:
return vec2d(-self.vec[1]/length, self.vec[0]/length)
return vec2d(self)
def normalize_return_length(self):
length = self.length
if length != 0:
self.vec[0] /= length
self.vec[1] /= length
return length
def dot(self, other):
return self.vec[0]*other[0] + self.vec[1]*other[1]
def get_distance(self, other):
return math.sqrt((self.vec[0] - other[0])**2 + (self.vec[1] - other[1])**2)
def projection(self, other):
normal = other.normalized()
projected_length = self.dot(normal)
return normal*projected_length
def cross(self, other):
return self.vec[0]*other[1] - self.vec[1]*other[0]
def interpolate_to(self, other, range):
return vec2d(self.vec[0] + (other.vec[0] - self.vec[0])*range, self.vec[1] + (other.vec[1] - self.vec[1])*range)
def convert_to_basis(self, x_vector, y_vector):
return vec2d(self.dot(x_vector)/x_vector.get_length_sqrd(), self.dot(y_vector)/y_vector.get_length_sqrd())
########################################################################
class vec2dTuple(tuple):
def __new__(cls, *args):
if len(args) == 1:
return tuple.__new__(cls, args[0])
else:
return tuple.__new__(cls, args)
def get_x(self):
return self[0]
x = property(get_x)
def get_y(self):
return self[1]
y = property(get_y)
# String representaion (for debugging)
def __repr__(self):
return 'vec2dTuple(%s, %s)' % (self.x, self.y)
# Comparison
def __eq__(self, other):
return self[0] == other[0] and self[1] == other[1]
def __ne__(self, other):
return self[0] != other[0] or self[1] != other[1]
def __nonzero__(self):
return self[0] or self[1]
# Generic operator handlers
def _o2(self, other, f):
"Any two-operator operation where the left operand is a vec2dTuple"
try:
return vec2dTuple(f(self[0], other[0]),
f(self[1], other[1]))
except TypeError:
return vec2dTuple(f(self[0], other),
f(self[1], other))
def _r_o2(self, other, f):
"Any two-operator operation where the right operand is a vec2dTuple"
try:
return vec2dTuple(f(other[0], self[0]),
f(other[1], self[1]))
except TypeError:
return vec2dTuple(f(other, self[0]),
f(other, self[1]))
def _o1(self, f):
"Any unary operation on a vec2dTuple"
return vec2dTuple(f(self[0]), f(self[1]))
# Addition
def __add__(self, other):
return self._o2(other, operator.add)
__radd__ = __add__
# Subtraction
def __sub__(self, other):
return self._o2(other, operator.sub)
def __rsub__(self, other):
return self._r_o2(other, operator.sub)
# Multiplication
def __mul__(self, other):
return self._o2(other, operator.mul)
__rmul__ = __mul__
# Division
def __div__(self, other):
return self._o2(other, operator.div)
def __rdiv__(self, other):
return self._r_o2(other, operator.div)
def __floordiv__(self, other):
return self._o2(other, operator.floordiv)
def __rfloordiv__(self, other):
return self._r_o2(other, operator.floordiv)
def __truediv__(self, other):
return self._o2(other, operator.truediv)
def __rtruediv__(self, other):
return self._r_o2(other, operator.truediv)
# Modulo
def __mod__(self, other):
return self._o2(other, operator.mod)
def __rmod__(self, other):
return self._r_o2(other, operator.mod)
def __divmod__(self, other):
return self._o2(other, operator.divmod)
def __rdivmod__(self, other):
return self._r_o2(other, operator.divmod)
# Exponentation
def __pow__(self, other):
return self._o2(other, operator.pow)
def __rpow__(self, other):
return self._r_o2(other, operator.pow)
# Bitwise operators
def __lshift__(self, other):
return self._o2(other, operator.lshift)
def __rlshift__(self, other):
return self._r_o2(other, operator.lshift)
def __rshift__(self, other):
return self._o2(other, operator.rshift)
def __rrshift__(self, other):
return self._r_o2(other, operator.rshift)
def __and__(self, other):
return self._o2(other, operator.and_)
__rand__ = __and__
def __or__(self, other):
return self._o2(other, operator.or_)
__ror__ = __or__
def __xor__(self, other):
return self._o2(other, operator.xor)
__rxor__ = __xor__
# Unary operations
def __neg__(self):
return self._o1(operator.neg)
def __pos__(self):
return self._o1(operator.pos)
def __abs__(self):
return self._o1(operator.abs)
def __invert__(self):
return self._o1(operator.invert)
# vectory functions
def get_length_sqrd(self):
return self[0]**2 + self[1]**2
def get_length(self):
return math.sqrt(self[0]**2 + self[1]**2)
length = property(get_length, None, None, "gets or sets the magnitude of the vector")
def get_angle(self):
if (self.get_length_sqrd() == 0):
return 0
return math.degrees(math.atan2(self[1], self[0]))
def get_angle_between(self, other):
cross = self[0]*other[1] - self[1]*other[0]
dot = self[0]*other[0] + self[1]*other[1]
return math.degrees(math.atan2(cross, dot))
angle = property(get_angle, None, None, "gets or sets the angle of a vector")
def normalized(self):
length = self.length
if length != 0:
return self/length
return vec2dTuple(self)
def perpendicular(self):
return vec2dTuple(-self[1], self[0])
def perpendicular_normal(self):
length = self.length
if length != 0:
return vec2dTuple(-self[1]/length, self[0]/length)
return vec2dTuple(self)
def normalize_return_length(self):
length = self.length
if length != 0:
self[0] /= length
self[1] /= length
return length
def dot(self, other):
return self[0]*other[0] + self[1]*other[1]
def get_distance(self, other):
return math.sqrt((self[0] - other[0])**2 + (self[1] - other[1])**2)
def projection(self, other):
normal = other.normalized()
projected_length = self.dot(normal)
return normal*projected_length
def cross(self, other):
return self[0]*other[1] - self[1]*other[0]
def interpolate_to(self, other, range):
return vec2dTuple(self[0] + (other[0] - self[0])*range, self[1] + (other[1] - self[1])*range)
def convert_to_basis(self, x_vector, y_vector):
return vec2dTuple(self.dot(x_vector)/x_vector.get_length_sqrd(), self.dot(y_vector)/y_vector.get_length_sqrd())
####
class vec2dExp(object):
def __init__(self, dx, dy):
self.dx = dx
self.dy = dy
def get_x(self):
return self.dx
x = property(get_x)
def get_y(self):
return self.dy
y = property(get_y)
# String representaion (for debugging)
def __repr__(self):
return 'vec2dExp(%s, %s)' % (self.x, self.y)
# Comparison
def __eq__(self, other):
return self.dx == other.dx and self.dy == other.dy
def __ne__(self, other):
return self.dx != other.dx or self.dy != other.dy
def __nonzero__(self):
return self.dx or self.dy
# Generic operator handlers
def _o2(self, other, f):
"Any two-operator operation where the left operand is a vec2dExp"
try:
return vec2dExp(f(self.dx, other.dx),
f(self.dy, other.dy))
except AttributeError:
return vec2dTuple(f(self.dx, other),
f(self.dy, other))
def _r_o2(self, other, f):
"Any two-operator operation where the right operand is a vec2dExp"
try:
return vec2dTuple(f(other.dx, self.dx),
f(other.dy, self.dy))
except AttributeError:
return vec2dTuple(f(other, self.dx),
f(other, self.dy))
def _o1(self, f):
"Any unary operation on a vec2dTuple"
return vec2dTuple(f(self.dx), f(self.dy))
# Addition
def __add__(self, other):
return self._o2(other, operator.add)
__radd__ = __add__
# Subtraction
def __sub__(self, other):
return self._o2(other, operator.sub)
def __rsub__(self, other):
return self._r_o2(other, operator.sub)
# Multiplication
def __mul__(self, other):
return self._o2(other, operator.mul)
__rmul__ = __mul__
# Division
def __div__(self, other):
return self._o2(other, operator.div)
def __rdiv__(self, other):
return self._r_o2(other, operator.div)
def __floordiv__(self, other):
return self._o2(other, operator.floordiv)
def __rfloordiv__(self, other):
return self._r_o2(other, operator.floordiv)
def __truediv__(self, other):
return self._o2(other, operator.truediv)
def __rtruediv__(self, other):
return self._r_o2(other, operator.truediv)
# Modulo
def __mod__(self, other):
return self._o2(other, operator.mod)
def __rmod__(self, other):
return self._r_o2(other, operator.mod)
def __divmod__(self, other):
return self._o2(other, operator.divmod)
def __rdivmod__(self, other):
return self._r_o2(other, operator.divmod)
# Exponentation
def __pow__(self, other):
return self._o2(other, operator.pow)
def __rpow__(self, other):
return self._r_o2(other, operator.pow)
# Bitwise operators
def __lshift__(self, other):
return self._o2(other, operator.lshift)
def __rlshift__(self, other):
return self._r_o2(other, operator.lshift)
def __rshift__(self, other):
return self._o2(other, operator.rshift)
def __rrshift__(self, other):
return self._r_o2(other, operator.rshift)
def __and__(self, other):
return self._o2(other, operator.and_)
__rand__ = __and__
def __or__(self, other):
return self._o2(other, operator.or_)
__ror__ = __or__
def __xor__(self, other):
return self._o2(other, operator.xor)
__rxor__ = __xor__
# Unary operations
def __neg__(self):
return self._o1(operator.neg)
def __pos__(self):
return self._o1(operator.pos)
def __abs__(self):
return self._o1(operator.abs)
def __invert__(self):
return self._o1(operator.invert)
# vectory functions
def get_length_sqrd(self):
return self.dx**2 + self.dy**2
def get_length(self):
return math.sqrt(self.dx**2 + self.dy**2)
length = property(get_length, None, None, "gets or sets the magnitude of the vector")
def get_angle(self):
if (self.get_length_sqrd() == 0):
return 0
return math.degrees(math.atan2(self.dx, self.dy))
def get_angle_between(self, other):
cross = self.dx*other.dy - self.dy*other.dx
dot = self.dx*other.dx + self.dy*other.dy
return math.degrees(math.atan2(cross, dot))
angle = property(get_angle, None, None, "gets or sets the angle of a vector")
def normalized(self):
length = self.length
if length != 0:
return self/length
return vec2dTuple(self)
def perpendicular(self):
return vec2dTuple(-self.dy, self.dx)
def perpendicular_normal(self):
length = self.length
if length != 0:
return vec2dTuple(-self.dy/length, self.dx/length)
return vec2dTuple(self)
def normalize_return_length(self):
length = self.length
if length != 0:
self[0] /= length
self[1] /= length
return length
def dot(self, other):
return self.dx*other.dx + self.dy*other.dy
def get_distance(self, other):
return math.sqrt((self.dx - other.dx)**2 + (self.dy - other.dy)**2)
def projection(self, other):
normal = other.normalized()
projected_length = self.dot(normal)
return normal*projected_length
def cross(self, other):
return self.dx*other.dy - self.dy*other.dx
def interpolate_to(self, other, range):
return vec2dTuple(self.dx + (other.dx - self.dx)*range, self.dy + (other.dy - self.dy)*range)
def convert_to_basis(self, x_vector, y_vector):
return vec2dTuple(self.dot(x_vector)/x_vector.get_length_sqrd(), self.dot(y_vector)/y_vector.get_length_sqrd())
########################################################################
## Unit Testing ##
########################################################################
if __name__ == "__main__":
import unittest
####################################################################
class UnitTestVec2D(unittest.TestCase):
def setUp(self):
pass
def testCreationAndAccess(self):
v = vec2d(111,222)
self.assert_(v.x == 111 and v.y == 222)
v.x = 333
v[1] = 444
self.assert_(v[0] == 333 and v[1] == 444)
def testMath(self):
v = vec2d(111,222)
self.assert_(v + 1 == vec2d(112,223))
self.assert_(v - 2 == [109,220])
self.assert_(v * 3 == (333,666))
self.assert_(v / 2.0 == vec2d(55.5, 111))
self.assert_(v / 2 == (55, 111))
self.assert_(v ** vec2d(2,3) == [12321, 10941048])
self.assert_(v + [-11, 78] == vec2d(100, 300))
self.assert_(v / [11,2] == [10,111])
def testReverseMath(self):
v = vec2d(111,222)
self.assert_(1 + v == vec2d(112,223))
self.assert_(2 - v == [-109,-220])
self.assert_(3 * v == (333,666))
self.assert_([222,999] / v == [2,4])
self.assert_([111,222] ** vec2d(2,3) == [12321, 10941048])
self.assert_([-11, 78] + v == vec2d(100, 300))
def testUnary(self):
v = vec2d(111,222)
v = -v
self.assert_(v == [-111,-222])
v = abs(v)
self.assert_(v == [111,222])
def testLength(self):
v = vec2d(3,4)
self.assert_(v.length == 5)
self.assert_(v.get_length_sqrd() == 25)
self.assert_(v.normalize_return_length() == 5)
self.assert_(v.length == 1)
v.length = 5
self.assert_(v == vec2d(3,4))
v2 = vec2d(10, -2)
self.assert_(v.get_distance(v2) == (v - v2).get_length())
def testAngles(self):
v = vec2d(0, 3)
self.assertEquals(v.angle, 90)
v2 = vec2d(v)
v.rotate(-90)
self.assertEqual(v.get_angle_between(v2), 90)
v2.angle -= 90
self.assertEqual(v.length, v2.length)
self.assertEquals(v2.angle, 0)
self.assertEqual(v2, [3, 0])
self.assert_((v - v2).length < .00001)
self.assertEqual(v.length, v2.length)
v2.rotate(300)
self.assertAlmostEquals(v.get_angle_between(v2), -60)
v2.rotate(v2.get_angle_between(v))
angle = v.get_angle_between(v2)
self.assertAlmostEquals(v.get_angle_between(v2), 0)
def testHighLevel(self):
basis0 = vec2d(5.0, 0)
basis1 = vec2d(0, .5)
v = vec2d(10, 1)
self.assert_(v.convert_to_basis(basis0, basis1) == [2, 2])
self.assert_(v.projection(basis0) == (10, 0))
self.assert_(basis0.dot(basis1) == 0)
def testCross(self):
lhs = vec2d(1, .5)
rhs = vec2d(4,6)
self.assert_(lhs.cross(rhs) == 4)
####################################################################
class UnitTestvec2dTuple(unittest.TestCase):
def setUp(self):
pass
def testCreationAndAccess(self):
v = vec2dTuple(111,222)
self.assert_(v.x == 111 and v.y == 222)
def testMath(self):
v = vec2dTuple(111,222)
self.assert_(v + 1 == vec2dTuple(112,223))
self.assert_(v - 2 == [109,220])
self.assert_(v * 3 == (333,666))
self.assert_(v / 2.0 == vec2dTuple(55.5, 111))
self.assert_(v / 2 == (55, 111))
self.assert_(v ** vec2dTuple(2,3) == [12321, 10941048])
self.assert_(v + [-11, 78] == vec2dTuple(100, 300))
self.assert_(v / [11,2] == [10,111])
self.assert_(v + (89, -122) == [200,100])
def testReverseMath(self):
v = vec2dTuple(111,222)
self.assert_(1 + v == vec2dTuple(112,223))
self.assert_(2 - v == [-109,-220])
self.assert_(3 * v == (333,666))
self.assert_([222,999] / v == [2,4])
self.assert_([111,222] ** vec2dTuple(2,3) == [12321, 10941048])
self.assert_([-11, 78] + v == vec2dTuple(100, 300))
self.assert_((89,-122) + v == [200,100])
def testUnary(self):
v = vec2dTuple(111,222)
v = -v
self.assert_(v == [-111,-222])
v = abs(v)
self.assert_(v == [111,222])
def testLength(self):
v = vec2dTuple(3,4)
self.assert_(v.length == 5)
self.assert_(v.get_length_sqrd() == 25)
v2 = v.normalized()
self.assert_(v2.length == 1)
v2 = vec2dTuple(10, -2)
self.assert_(v.get_distance(v2) == (v - v2).get_length())
def testAngles(self):
v = vec2dTuple(0, 3)
self.assertEquals(v.angle, 90)
v2 = vec2dTuple(v)
self.assertEqual(v.length, v2.length)
def testHighLevel(self):
basis0 = vec2dTuple(5.0, 0)
basis1 = vec2dTuple(0, .5)
v = vec2dTuple(10, 1)
self.assert_(v.convert_to_basis(basis0, basis1) == [2, 2])
self.assert_(v.projection(basis0) == (10, 0))
self.assert_(basis0.dot(basis1) == 0)
def testCross(self):
lhs = vec2dTuple(1, .5)
rhs = vec2dTuple(4,6)
self.assert_(lhs.cross(rhs) == 4)
########################################################################
import time
def perfTest(func, num_runs = 10000, fps=60, budget=.05):
start = time.clock()
func(num_runs)
end = time.clock()
elapsed = end - start
print "time: ", elapsed
print "%s runs at %.1f loops/s" % (str(func), num_runs/elapsed)
print "that's %.2f loops to fill %d fps" % (num_runs/elapsed/fps, fps)
print "or %.2f at a %.1f%% budget at %d fps" % (budget*num_runs/elapsed/fps, budget*100.0, fps)
class TestData:
screen_offsetx = 100
screen_offsety = 120
screen_offset = vec2d(screen_offsetx, screen_offsety)
screen_offset_tuple = vec2dTuple(screen_offsetx, screen_offsety)
screen_offset_exp = vec2dExp(screen_offsetx, screen_offsety)
screen_scale = .5
object_positionx = 130.5
object_positiony = 191.5
object_position = vec2d(object_positionx, object_positiony)
object_position_tuple = vec2dTuple(object_positionx, object_positiony)
object_position_exp = vec2dExp(object_positionx, object_positiony)
def ScreenTranslationTestVec2d(loop_count):
for i in xrange(loop_count):
final_pos = (TestData.object_position_tuple - TestData.screen_offset_tuple)*TestData.screen_scale
def ScreenTranslationTestVec2dTuple(loop_count):
for i in xrange(loop_count):
final_pos = (TestData.object_position_tuple - TestData.screen_offset_tuple)*TestData.screen_scale
def ScreenTranslationTestVec2dExp(loop_count):
for i in xrange(loop_count):
final_pos = (TestData.object_position_exp - TestData.screen_offset_exp)*TestData.screen_scale
def ScreenTranslationTestExplicit(loop_count):
for i in xrange(loop_count):
final_posx = (TestData.object_positionx - TestData.screen_offsetx)*TestData.screen_scale
final_posy = (TestData.object_positiony - TestData.screen_offsety)*TestData.screen_scale
########################################################################
print "testing vector code..."
perfTest(ScreenTranslationTestVec2d)
perfTest(ScreenTranslationTestVec2dTuple)
perfTest(ScreenTranslationTestExplicit)
print "\nnow psychoing everything..."
import psyco
psyco.bind(ScreenTranslationTestVec2d)
psyco.bind(ScreenTranslationTestVec2dTuple)
psyco.bind(ScreenTranslationTestVec2dExp)
psyco.bind(ScreenTranslationTestExplicit)
perfTest(ScreenTranslationTestVec2d)
perfTest(ScreenTranslationTestVec2dTuple)
perfTest(ScreenTranslationTestVec2dExp)
perfTest(ScreenTranslationTestExplicit)
#####################################################################
unittest.main()
#####################################################################
Attachment:
signature.asc
Description: OpenPGP digital signature