Implement == and != for vectors

Author: BruceSherwood

vpython/cyvector.pyx

@@ -31,9 +31,9 @@ cdef class vector(object):
             self._z = args[2]
         elif len(args) == 1 and isinstance(args[0], vector): # make a copy of a vector
             other = args[0]
-            self._x = other.x
-            self._y = other.y
-            self._z = other.z
+            self._x = other._x
+            self._y = other._y
+            self._z = other._z
         else:
             raise TypeError('A vector needs 3 components.')
         self.on_change = self.ignore
@@ -43,14 +43,14 @@ cdef class vector(object):
 
     property value:
         def __get__(self):
-            return [self.x, self.y, self.z]
+            return [self._x, self._y, self._z]
         def __set__(self, other):
-            self._x = other.x
-            self._y = other.y
-            self._z = other.z
+            self._x = other._x
+            self._y = other._y
+            self._z = other._z
 
     def __neg__(self):  ## seems like this must come before properties (???)
-        return vector(-self.x, -self.y, -self.z)
+        return vector(-self._x, -self._y, -self._z)
 
     def __pos__(self):
         return self
@@ -62,24 +62,34 @@ cdef class vector(object):
         return '<{:.6g}, {:.6g}, {:.6g}>'.format(self._x, self._y, self._z)
 
     def __add__(self,other):
-        return vector(self.x + other.x, self.y + other.y, self.z + other.z)
+        return vector(self._x + other._x, self._y + other._y, self._z + other._z)
 
     def __truediv__(self, other): # Python 3, or Python 2 + future division
         if isinstance(other, (int, float)):
-            return vector(self.x / other, self.y / other, self.z / other)
+            return vector(self._x / other, self._y / other, self._z / other)
         raise TypeError('a vector can only be divided by a scalar')
 
     def __sub__(self,other):
-        return vector(self.x - other.x, self.y - other.y, self.z - other.z)
+        return vector(self._x - other._x, self._y - other._y, self._z - other._z)
 
     def __mul__(self, other):  ## in cython order of arguments is arbitrary, rmul doesn't exist
         if isinstance(other, (int, float)):
-            return vector(self.x * other, self.y * other, self. z * other)
+            return vector(self._x * other, self._y * other, self._z * other)
         elif isinstance(self, (int, float)):
-            return vector(self * other.x, self * other.y, self * other.z)
+            return vector(self * other._x, self * other._y, self * other._z)
         else:
             raise TypeError('a vector can only be multiplied by a scalar', self, other)
 
+    def __eq__(self,other):
+        if type(self) is vector and type(other) is vector:
+            return self.equals(other)
+        return False
+
+    def __ne__(self,other):
+        if type(self) is vector and type(other) is vector:
+            return not self.equals(other)
+        return True
+
     property x:
         def __get__(self):
             return self._x
@@ -103,18 +113,18 @@ cdef class vector(object):
 
     property mag:
         def __get__(self):
-            return sqrt(self.x**2 + self.y**2 + self.z**2)
+            return sqrt(self._x**2 + self._y**2 + self._z**2)
         def __set__(self, value):
             cdef vector normA
             normA = self.hat
-            self.x = value * normA.x
-            self.y = value * normA.y
-            self.z = value * normA.z
+            self.x = value * normA._x
+            self.y = value * normA._y
+            self.z = value * normA.vz
             self.on_change()
 
     property mag2:
         def __get__(self):
-            return (self.x**2 + self.y**2 + self.z**2)
+            return (self._x**2 + self._y**2 + self._z**2)
         def __set__(self, value):
             cdef double v
             v = sqrt(value)
@@ -134,30 +144,30 @@ cdef class vector(object):
             smag = self.mag
             cdef vector normA
             normA = value.hat
-            self.x = smag * normA.x
-            self.y = smag * normA.y
-            self.z = smag * normA.z
+            self.x = smag * normA._x
+            self.y = smag * normA._y
+            self.z = smag * normA._z
             self.on_change()
 
 
     cpdef vector norm(self):
         return self.hat
 
     cpdef double dot(self,other):
-        return ( self.x*other.x + self.y*other.y + self.z*other.z )
+        return ( self._x*other._x + self._y*other._y + self._z*other._z )
 
     cpdef vector cross(self,other):
-        return vector( self.y*other.z-self.z*other.y,
-                       self.z*other.x-self.x*other.z,
-                       self.x*other.y-self.y*other.x )
+        return vector( self._y*other._z-self._z*other._y,
+                       self._z*other._x-self._x*other._z,
+                       self._x*other._y-self._y*other._x )
 
     cpdef vector proj(self,other):
         cdef vector normB
         normB = other.hat
         return self.dot(normB) * normB
 
     cpdef bint equals(self,other):
-        return ( self.x == other.x and self.y == other.y and self.z == other.z )
+        return ( self._x == other._x and self._y == other._y and self._z == other._z )
 
     cpdef double comp(self,other):  ## result is a scalar
         cdef vector normB
@@ -175,16 +185,16 @@ cdef class vector(object):
 
     cpdef vector rotate(self, double angle=0., vector axis=None):
         cdef vector u
-        if axis == None:
+        if axis is None:
             u = vector(0,0,1)
         else:
             u = axis.hat
         cdef double c = cos(angle)
         cdef double s = sin(angle)
         cdef double t = 1.0 - c
-        cdef double x = u.x
-        cdef double y = u.y
-        cdef double z = u.z
+        cdef double x = u._x
+        cdef double y = u._y
+        cdef double z = u._z
         cdef double m11 = t*x*x+c
         cdef double m12 = t*x*y-z*s
         cdef double m13 = t*x*z+y*s
@@ -194,25 +204,25 @@ cdef class vector(object):
         cdef double m31 = t*x*z-y*s
         cdef double m32 = t*y*z+x*s
         cdef double m33 = t*z*z+c
-        cdef double sx = self.x
-        cdef double sy = self.y
-        cdef double sz = self.z
+        cdef double sx = self._x
+        cdef double sy = self._y
+        cdef double sz = self._z
         return vector( (m11*sx + m12*sy + m13*sz),
                     (m21*sx + m22*sy + m23*sz),
                     (m31*sx + m32*sy + m33*sz) )
 
     cpdef rotate_in_place(self, double angle=0., vector axis=None):
         cdef vector u
-        if axis == None:
+        if axis is None:
             u = vector(0,0,1)
         else:
             u = axis.hat
         cdef double c = cos(angle)
         cdef double s = sin(angle)
         cdef double t = 1.0 - c
-        cdef double x = u.x
-        cdef double y = u.y
-        cdef double z = u.z
+        cdef double x = u._x
+        cdef double y = u._y
+        cdef double z = u._z
         cdef double m11 = t*x*x+c
         cdef double m12 = t*x*y-z*s
         cdef double m13 = t*x*z+y*s
@@ -222,9 +232,9 @@ cdef class vector(object):
         cdef double m31 = t*x*z-y*s
         cdef double m32 = t*y*z+x*s
         cdef double m33 = t*z*z+c
-        cdef double sx = self.x
-        cdef double sy = self.y
-        cdef double sz = self.z
+        cdef double sx = self._x
+        cdef double sy = self._y
+        cdef double sz = self._z
         self._x = m11*sx + m12*sy + m13*sz
         self._y = m21*sx + m22*sy + m23*sz
         self._z = m31*sx + m32*sy + m33*sz
@@ -234,9 +244,9 @@ cpdef object_rotate(vector objaxis, vector objup, double angle, vector axis):
     cdef double c = cos(angle)
     cdef double s = sin(angle)
     cdef double t = 1.0 - c
-    cdef double x = u.x
-    cdef double y = u.y
-    cdef double z = u.z
+    cdef double x = u._x
+    cdef double y = u._y
+    cdef double z = u._z
     cdef double m11 = t*x*x+c
     cdef double m12 = t*x*y-z*s
     cdef double m13 = t*x*z+y*s
@@ -246,15 +256,15 @@ cpdef object_rotate(vector objaxis, vector objup, double angle, vector axis):
     cdef double m31 = t*x*z-y*s
     cdef double m32 = t*y*z+x*s
     cdef double m33 = t*z*z+c
-    cdef double sx = objaxis.x
-    cdef double sy = objaxis.y
-    cdef double sz = objaxis.z
+    cdef double sx = objaxis._x
+    cdef double sy = objaxis._y
+    cdef double sz = objaxis._z
     objaxis._x = m11*sx + m12*sy + m13*sz # avoid creating a new vector object
     objaxis._y = m21*sx + m22*sy + m23*sz
     objaxis._z = m31*sx + m32*sy + m33*sz
-    sx = objup.x
-    sy = objup.y
-    sz = objup.z
+    sx = objup._x
+    sy = objup._y
+    sz = objup._z
     objup._x = m11*sx + m12*sy + m13*sz
     objup._y = m21*sx + m22*sy + m23*sz
     objup._z = m31*sx + m32*sy + m33*sz
@@ -294,7 +304,7 @@ cpdef vector rotate(vector A, double angle = 0., vector axis = None):
 cpdef vector adjust_up(vector oldaxis, vector newaxis, vector up, vector save_oldaxis): # adjust up when axis is changed
     cdef double angle
     cdef vector rotaxis
-    if abs(newaxis.x) + abs(newaxis.y) + abs(newaxis.z) == 0:
+    if abs(newaxis._x) + abs(newaxis._y) + abs(newaxis._z) == 0:
         # If axis has changed to <0,0,0>, must save the old axis to restore later
         if save_oldaxis is None: save_oldaxis = oldaxis
         return save_oldaxis
@@ -321,7 +331,7 @@ cpdef vector adjust_up(vector oldaxis, vector newaxis, vector up, vector save_ol
 cpdef vector adjust_axis(vector oldup, vector newup, vector axis, vector save_oldup): # adjust axis when up is changed
     cdef double angle
     cdef vector rotaxis
-    if abs(newup.x) + abs(newup.y) + abs(newup.z) == 0:
+    if abs(newup._x) + abs(newup._y) + abs(newup._z) == 0:
         # If up will be set to <0,0,0>, must save the old up to restore later
         if save_oldup is None: save_oldup = oldup
         return save_oldup

vpython/vector.py

@@ -77,6 +77,16 @@ def __rmul__(self, other):
         except:
             raise TypeError('a vector can only be multiplied by a scalar')
 
+    def __eq__(self,other):
+        if type(self) is vector and type(other) is vector:
+            return self.equals(other)
+        return False
+
+    def __ne__(self,other):
+        if type(self) is vector and type(other) is vector:
+            return not self.equals(other)
+        return True
+
     @property
     def x(self):
         return self._x
@@ -171,16 +181,16 @@ def diff_angle(self, other):
         return acos(a)
 
     def rotate(self, angle=0., axis=None):
-        if axis == None:
+        if axis is None:
             u = vector(0,0,1)
         else:
             u = axis.hat
         c = cos(angle)
         s = sin(angle)
         t = 1.0 - c
-        x = u.x
-        y = u.y
-        z = u.z
+        x = u._x
+        y = u._y
+        z = u._z
         m11 = t*x*x+c
         m12 = t*x*y-z*s
         m13 = t*x*z+y*s
@@ -190,24 +200,24 @@ def rotate(self, angle=0., axis=None):
         m31 = t*x*z-y*s
         m32 = t*y*z+x*s
         m33 = t*z*z+c
-        sx = self.x
-        sy = self.y
-        sz = self.z
+        sx = self._x
+        sy = self._y
+        sz = self._z
         return vector( (m11*sx + m12*sy + m13*sz),
                     (m21*sx + m22*sy + m23*sz),
                     (m31*sx + m32*sy + m33*sz) )
 
     def rotate_in_place(self, angle=0., axis=None):
-        if axis == None:
+        if axis is None:
             u = vector(0,0,1)
         else:
             u = axis.hat
         c = cos(angle)
         s = sin(angle)
         t = 1.0 - c
-        x = u.x
-        y = u.y
-        z = u.z
+        x = u._x
+        y = u._y
+        z = u._z
         m11 = t*x*x+c
         m12 = t*x*y-z*s
         m13 = t*x*z+y*s
@@ -217,9 +227,9 @@ def rotate_in_place(self, angle=0., axis=None):
         m31 = t*x*z-y*s
         m32 = t*y*z+x*s
         m33 = t*z*z+c
-        sx = self.x
-        sy = self.y
-        sz = self.z
+        sx = self._x
+        sy = self._y
+        sz = self._z
         self._x = m11*sx + m12*sy + m13*sz
         self._y = m21*sx + m22*sy + m23*sz
         self._z = m31*sx + m32*sy + m33*sz
@@ -229,9 +239,9 @@ def object_rotate(objaxis, objup, angle, axis):
     c = cos(angle)
     s = sin(angle)
     t = 1.0 - c
-    x = u.x
-    y = u.y
-    z = u.z
+    x = u._x
+    y = u._y
+    z = u._z
     m11 = t*x*x+c
     m12 = t*x*y-z*s
     m13 = t*x*z+y*s
@@ -241,15 +251,15 @@ def object_rotate(objaxis, objup, angle, axis):
     m31 = t*x*z-y*s
     m32 = t*y*z+x*s
     m33 = t*z*z+c
-    sx = objaxis.x
-    sy = objaxis.y
-    sz = objaxis.z
+    sx = objaxis._x
+    sy = objaxis._y
+    sz = objaxis._z
     objaxis._x = m11*sx + m12*sy + m13*sz # avoid creating a new vector object
     objaxis._y = m21*sx + m22*sy + m23*sz
     objaxis._z = m31*sx + m32*sy + m33*sz
-    sx = objup.x
-    sy = objup.y
-    sz = objup.z
+    sx = objup._x
+    sy = objup._y
+    sz = objup._z
     objup._x = m11*sx + m12*sy + m13*sz
     objup._y = m21*sx + m22*sy + m23*sz
     objup._z = m31*sx + m32*sy + m33*sz
@@ -285,7 +295,7 @@ def rotate(A, angle=0., axis = None):
     return A.rotate(angle,axis)
 
 def adjust_up(oldaxis, newaxis, up, save_oldaxis): # adjust up when axis is changed
-    if abs(newaxis.x) + abs(newaxis.y) + abs(newaxis.z) == 0:
+    if abs(newaxis._x) + abs(newaxis._y) + abs(newaxis._z) == 0:
         # If axis has changed to <0,0,0>, must save the old axis to restore later
         if save_oldaxis is None: save_oldaxis = oldaxis
         return save_oldaxis
@@ -310,7 +320,7 @@ def adjust_up(oldaxis, newaxis, up, save_oldaxis): # adjust up when axis is chan
     return save_oldaxis
 
 def adjust_axis(oldup, newup, axis, save_oldup): # adjust axis when up is changed
-    if abs(newup.x) + abs(newup.y) + abs(newup.z) == 0:
+    if abs(newup._x) + abs(newup._y) + abs(newup._z) == 0:
         # If up will be set to <0,0,0>, must save the old up to restore later
         if save_oldup is None: save_oldup = oldup
         return save_oldup