

from cva import destroyAllWindows, imread, imshow, waitKey


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase,	__lowerCAmelCase					=							img.shape[0], img.shape[1]

					# converting each pixel's color to its negative
					for i in range(_UpperCAmelCase      ):
										for j in range(_UpperCAmelCase      ):
															__lowerCAmelCase					=							[255, 255, 255] - img[i][j]

					return img


if __name__ == "__main__":
		# read original image
		lowerCamelCase      				=						imread('''image_data/lena.jpg''', 1)

		# convert to its negative
		lowerCamelCase      				=						convert_to_negative(img)

		# show result image
		imshow('''negative of original image''', img)
		waitKey(0)
		destroyAllWindows()









from __future__ import annotations

from collections.abc import MutableSequence





class     snake_case_			:


							"""simple docstring"""





							def __init__( self					,						_A					,						_A							):
												if len(_A							) != degree + 1:
																	raise ValueError(
																	    'The number of coefficients should be equal to the degree + 1.'							)

												__lowerCAmelCase					=							list(_A							)
												__lowerCAmelCase					=							degree




							def __add__( self					,						_A							):

												if self.degree > polynomial_a.degree:
																	__lowerCAmelCase					=							self.coefficients[:]
																	for i in range(polynomial_a.degree + 1							):
																						coefficients[i] += polynomial_a.coefficients[i]
																	return Polynomial(self.degree					,						_A							)
												else:
																	__lowerCAmelCase					=							polynomial_a.coefficients[:]
																	for i in range(self.degree + 1							):
																						coefficients[i] += self.coefficients[i]
																	return Polynomial(polynomial_a.degree					,						_A							)




							def __sub__( self					,						_A							):
												return self + polynomial_a * Polynomial(0					,						[-1]							)




							def __neg__( self							):
												return Polynomial(self.degree					,						[-c for c in self.coefficients]							)




							def __mul__( self					,						_A							):
												__lowerCAmelCase					=							[0] * (self.degree + polynomial_a.degree + 1)
												for i in range(self.degree + 1							):
																	for j in range(polynomial_a.degree + 1							):
																						coefficients[i + j] += (
																						    self.coefficients[i] * polynomial_a.coefficients[j]
																						)

												return Polynomial(self.degree + polynomial_a.degree					,						_A							)




							def        A__  ( self					,						_A							):
												__lowerCAmelCase					=							0
												for i in range(self.degree + 1							):
																	result += self.coefficients[i] * (substitution**i)
												return result




							def __str__( self							):
												__lowerCAmelCase					=							''
												for i in range(self.degree					,						-1					,						-1							):
																	if self.coefficients[i] == 0:
																						continue
																	elif self.coefficients[i] > 0:
																						if polynomial:
																											polynomial += " + "
																	else:
																						polynomial += " - "

																	if i == 0:
																						polynomial += str(abs(self.coefficients[i]							)							)
																	elif i == 1:
																						polynomial += str(abs(self.coefficients[i]							)							) + "x"
																	else:
																						polynomial += str(abs(self.coefficients[i]							)							) + "x^" + str(_A							)

												return polynomial




							def __repr__( self							):
												return self.__str__()




							def        A__  ( self							):
												__lowerCAmelCase					=							[0] * self.degree
												for i in range(self.degree							):
																	__lowerCAmelCase					=							self.coefficients[i + 1] * (i + 1)
												return Polynomial(self.degree - 1					,						_A							)




							def        A__  ( self					,						_A = 0							):
												__lowerCAmelCase					=							[0] * (self.degree + 2)
												__lowerCAmelCase					=							constant
												for i in range(self.degree + 1							):
																	__lowerCAmelCase					=							self.coefficients[i] / (i + 1)
												return Polynomial(self.degree + 1					,						_A							)




							def __eq__( self					,						_A							):
												if not isinstance(_A					,						_A							):
																	return False

												if self.degree != polynomial_a.degree:
																	return False

												for i in range(self.degree + 1							):
																	if self.coefficients[i] != polynomial_a.coefficients[i]:
																						return False

												return True




							def __ne__( self					,						_A							):
												return not self.__eq__(_A							)






