MolDyn/vector.py at origin · Emilinya/MolDyn · GitHub

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import math

class Vector3:
	def __init__(self, x=0, y=0, z=0):
		self.x = x
		self.y = y
		self.z = z

	def dot(self, other):
		if hasattr(other, "__getitem__") and len(other) == 3:
			return self.x*other[0] + self.y*other[1] + self.z*other[2]

	def __len__(self):
		return 3

	def __getitem__(self, key):
		if key == 0:
			return self.x
		elif key == 1:
			return self.y
		elif key == 2:
			return self.z
		else:
			raise IndexError("Invalid subscript "+str(key)+" to Vec2d")

	def __setitem__(self, key, value):
		if key == 0:
			self.x = value
		elif key == 1:
			self.y = value
		elif key == 2:
			self.z = value
		else:
			raise IndexError("Invalid subscript "+str(key)+" to Vec2d")

	# String representaion (for debugging)
	def __repr__(self):
		return f"[{self.x}, {self.y}, {self.z}]"

	# Comparison
	def __eq__(self, other):
		if hasattr(other, "__getitem__") and len(other) == 3:
			return self.x == other[0] and self.y == other[1] and self.z == other[2]
		else:
			return False

	def __ne__(self, other):
		if hasattr(other, "__getitem__") and len(other) == 3:
			return self.x != other[0] or self.y != other[1] and self.z == other[2]
		else:
			return True

	# Addition
	def __add__(self, other):
		if isinstance(other, Vector3):
			return Vector3(self.x + other.x, self.y + other.y, self.z + other.z)
		elif hasattr(other, "__getitem__"):
			return Vector3(self.x + other[0], self.y + other[1], self.z + other[2])
		else:
			return Vector3(self.x + other, self.y + other, self.z + other)
	__radd__ = __add__

	# Subtraction
	def __sub__(self, other):
		if isinstance(other, Vector3):
			return Vector3(self.x - other.x, self.y - other.y, self.z - other.z)
		elif hasattr(other, "__getitem__"):
			return Vector3(self.x - other[0], self.y - other[1], self.z - other[2])
		else:
			return Vector3(self.x - other, self.y - other, self.z - other)

	def __rsub__(self, other):
		if isinstance(other, Vector3):
			return Vector3(other.x - self.x, other.y - self.y, other.z - self.z)
		elif hasattr(other, "__getitem__"):
			return Vector3(other[0] - self.x, other[1] - self.y, other[2] - self.z)
		else:
			return Vector3(other - self.x, other - self.y, other - self.z)

	# Multiplication
	def __mul__(self, other):
		if isinstance(other, Vector3):
			return Vector3(self.x*other.x, self.y*other.y, self.z*other.z)
		elif hasattr(other, "__getitem__"):
			return Vector3(self.x*other[0], self.y*other[1], self.z*other[2])
		else:
			return Vector3(self.x*other, self.y*other, self.z*other)
	__rmul__ = __mul__

	# Division
	def __truediv__(self, other):
		if isinstance(other, Vector3):
			return Vector3(self.x/other.x, self.y/other.y, self.z/other.z)
		elif hasattr(other, "__getitem__"):
			return Vector3(self.x/other[0], self.y/other[1], self.z/other[2])
		else:
			return Vector3(self.x/other, self.y/other, self.z/other)
	__rtruediv__ = __truediv__

	def __abs__(self):
		return Vector3(abs(self.x), abs(self.y), abs(self.z))

	def __invert__(self):
		return Vector3(-self.x, -self.y, -self.z)

	# vectory functions
	def get_length_sqrd(self):
		return self.x**2 + self.y**2 + self.z**2

	def get_length(self):
		return math.sqrt(self.x**2 + self.y**2 + self.z**2)

	def __setlength(self, value):
		length = self.get_length()
		self.x *= value/length
		self.y *= value/length
		self.z *= value/length
	length = property(get_length, __setlength, None, "gets or sets the magnitude of the vector")

	def normalize(self):
		length = self.length
		if length != 0:
			return self/length
		return Vector3(self)

	def set(self, x, y, z):
		self.x = x
		self.y = y
		self.z = z
		return self

	def copy(self):
		return Vector3(self.x, self.y, self.z)