семестр 1 / lab11

class Triangle:

	def __init__(self, A, B, C):
		
		check_a = False
		check_b = False
		check_c = False
		self.A = A
		self.B = B
		self.C = C
		self.kre = True

		try:
			float(self.A[0])
			float(self.A[1])
			float(self.B[0])
			float(self.B[1])
		except:
			check_a = True

		try:	
			float(self.B[0])
			float(self.B[1])
			float(self.C[0])
			float(self.C[1])
		except:
			check_b = True

		try:
			float(self.C[0])
			float(self.C[1])
			float(self.A[0])
			float(self.A[1])
		except:
			check_c = True

		if check_a == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_a == False:
			self._a = (((self.B[0] - self.A[0])**2 + (self.B[1] - self.A[1])**2))**0.5

		if check_b == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_b == False:		
			self._b = (((self.C[0] - self.B[0])**2 + (self.C[1] - self.B[1])**2))**0.5

		if check_c == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_c == False:
			self._c = (((self.A[0] - self.C[0])**2 + (self.A[1] - self.C[1])**2))**0.5

		if self.kre == True:
			if self._a > 0 and self._b > 0 and self._c > 0:
				self.kre = True
			else:
				self.kre = False

		if self.kre == True:
			if self._a < (self._b + self._c) and self._b < (self._c + self._a) and self._c < (self._a + self._b):
				self.kre = True
			else:
				self.kre = False

		if self.kre == True:
			self.halfperimeter =  (self._a + self._b + self._c) / 2
			self.square = (self.halfperimeter * (self.halfperimeter - self._a) * (self.halfperimeter - self._b) * (self.halfperimeter - self._c))**0.5
			print("Triangle creation was successful.", chr(10))
		elif self.kre == False:
			print("Tringle creation failed.", chr(10))

	@property
	def a(self):
		return self.A
	@a.setter
	def a(self, val):
		self.A = val
		self.__init__(self.A, self.B, self.C)
	
	@property
	def b(self):
		return self.B
	@b.setter
	def b(self, val):
		self.B = val
		self.__init__(self.A, self.B, self.C)
	
	@property
	def c(self):
		return self.C
	@c.setter
	def c(self, val):
		self.C = val
		self.__init__(self.A, self.B, self.C)
	
	def per(self):

		if self.kre == True:
			self.perimeter = self.halfperimeter * 2
			print(f'Perimeter of this triangle is {self.perimeter}. {chr(10)}')
		else:
			print("Perimeter calculation failed: this triangle does not exists.", chr(10))

	def sq(self):
		
		if self.kre == True:
			self.square = (self.halfperimeter * (self.halfperimeter - self._a) * (self.halfperimeter - self._b) * (self.halfperimeter - self._c))**0.5
			print(f'Square of this triangle is {self.square}. {chr(10)}')
		else:
			print("Square calculation failed: this triangle does not exists.", chr(10))

	def md(self):
		
		if self.kre == True:
			self.median_M1 = ((2 * (self._a**2 + self._c**2) - self._b**2)**0.5 / 2) # to BC
			self.median_M2 = ((2 * (self._a**2 + self._b**2) - self._c**2)**0.5 / 2) # to CA
			self.median_M3 = ((2 * (self._c**2 + self._b**2) - self._a**2)**0.5 / 2) # to AB
			print(f'Median M1 to side «b» is {self.median_M1}.')
			print(f'Median M2 to side «c» is {self.median_M2}.')
			print(f'Median M3 to side «a» is {self.median_M3}. {chr(10)}')
		else:
			print("Medians calculation failed: this triangle does not exists.", chr(10))

	def ht(self):

		if self.kre == True:
			self.hight_H1 = 2 * self.square / self._b # to BC
			self.hight_H2 = 2 * self.square / self._c # to CA
			self.hight_H3 = 2 * self.square / self._a # to AB
			print(f'Hight H1 to side «b» is {self.hight_H1}.')
			print(f'Hight H2 to side «c» is {self.hight_H2}.')
			print(f'Hight H3 to side «a» is {self.hight_H3}. {chr(10)}')
		else:
			print("Hights calculation failed: this triangle does not exists.", chr(10))

	def sdeq(self):

		if self.kre == True:

			if self._a == self._b == self._c:
				print(f'This triangle is equal-sided because side «a» is equal to sides «b» and «c». {chr(10)}')
			elif self._a == self._b:
				print(f'This triangle is isosceles because side «a» is equal to sides «b». {chr(10)}')
			elif self._b == self._c:
				print(f'This triangle is isosceles because side «b» is equal to sides «c». {chr(10)}')
			elif self._c == self._a:
				print(f'This triangle is isosceles because side «c» is equal to sides «a». {chr(10)}')
		else:
			print("Sides comparison failed: this triangle does not exists.", chr(10))

	def __eq__(self,other):

		if self._a == other.AB and self._b == other.BC and self._c == other.CA:
			return True
		else:
			return False

	def sqeq(self, other):

		if self.square == other.square:
			return True
		else:
			return False

	def pr(self):

		if self.kre == True:
			print(f'This is triangle with sides {self._a}, {self._b}, {self._c}. {chr(10)}')
		else:
			print("Output failed: this triangle does not exists.", chr(10))

class Consttri(Triangle):

	@property
	def a(self):
		return self.A
	@a.setter
	def a(self, val):
		print("Invalid operation", chr(10))
	
	@property
	def b(self):
		return self.B
	@b.setter
	def b(self, val):
		print("Invalid operation", chr(10))
	
	@property
	def c(self):
		return self.C
	@c.setter
	def c(self, val):
		print("Invalid operation", chr(10))

class Rtgtri(Triangle):
	
	def __init__(self, A, B, C):

		check_a = False
		check_b = False
		check_c = False
		self.A = A
		self.B = B
		self.C = C
		self.kre = True

		try:
			float(self.A[0])
			float(self.A[1])
			float(self.B[0])
			float(self.B[1])
		except:
			check_a = True

		try:	
			float(self.B[0])
			float(self.B[1])
			float(self.C[0])
			float(self.C[1])
		except:
			check_b = True

		try:
			float(self.C[0])
			float(self.C[1])
			float(self.A[0])
			float(self.A[1])
		except:
			check_c = True

		if check_a == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_a == False:
			self._a = (((self.B[0] - self.A[0])**2 + (self.B[1] - self.A[1])**2))**0.5

		if check_b == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_b == False:		
			self._b = (((self.C[0] - self.B[0])**2 + (self.C[1] - self.B[1])**2))**0.5

		if check_c == True:
			print("Invalid input data: one of the points is not a vector.")
			self.kre = False
		elif check_c == False:
			self._c = (((self.A[0] - self.C[0])**2 + (self.A[1] - self.C[1])**2))**0.5

		if self.kre == True:
			if self._a > 0 and self._b > 0 and self._c > 0:
				self.kre = True
			else:
				self.kre = False

		if self.kre == True:
			if self._a < (self._b + self._c) and self._b < (self._c + self._a) and self._c < (self._a + self._b):
				self.kre = True
			else:
				self.kre = False

		if self.kre == True:
			if self._a**2 == self._b**2 + self._c**2:
				self.kre = True
			elif self._b**2 == self._a**2 + self._c**2:
				self.kre = True
			elif self._c**2 == self._a**2 + self._b**2:
				self.kre = True
			else:
				self.kre = False

		if self.kre == True:
			self.halfperimeter =  (self._a + self._b + self._c) / 2
			self.square = (self.halfperimeter * (self.halfperimeter - self._a) * (self.halfperimeter - self._b) * (self.halfperimeter - self._c))**0.5
			print("Triangle creation was successful.", chr(10))
		elif self.kre == False:
			print("Tringle creation failed.", chr(10))

#First task check
print("==================================================", chr(10))
ABC = Triangle([5,35],[12,-2],[6,26])
ABC.sq()
ABC.a = [3,5]
ABC.b = [7,9]
ABC.c = [6,-5]
ABC.sq()
print("==================================================", chr(10))

#Second task check
BFT = Triangle([5,36],[12,-3],[6,27])
FTR = Triangle([4,12],[34,3],[12,4])
if BFT.sqeq(FTR) == True:
	print("BFT equal FTR", chr(10))
else:
	print("BFT not equal FTR", chr(10))
print("==================================================", chr(10))

#Third task check
NYT = Consttri([45,6],[21,1],[12,4])
NYT.sq()
NYT.a = [1,3]
NYT.sq()
print("==================================================", chr(10))

#Forth task check
YHU = Rtgtri([-3,-2],[0,-1],[-2,5])
GTY = Rtgtri([4,3],[1,34],[242,78])