



"""simple docstring"""







class       _a  :



			def __init__(			self							:				Union[str, Any]   ,	_lowercase							:				int		)							->					Dict:
									snake_case   :			Optional[Any]						    = n
									snake_case   :			str						    = [None] * self.n
									snake_case   :			List[str]						    = 0  # index of the first element
									snake_case   :			Tuple						    = 0
									snake_case   :			str						    = 0



			def __len__(			self							:				Union[str, Any]		)							->					int:
									return self.size



			def 				__lowercase					(			self							:				Any		)							->					bool:
									return self.size == 0



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					Dict:
									return False if self.is_empty() else self.array[self.front]



			def 				__lowercase					(			self							:				Tuple   ,	_lowercase							:				Union[str, Any]		)							->					Union[str, Any]:

									if self.size >= self.n:
															raise Exception("QUEUE IS FULL"		)

									snake_case   :			Union[str, Any]						    = data
									snake_case   :			Optional[Any]						    = (self.rear + 1) % self.n
									self.size += 1
									return self



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					Dict:

									if self.size == 0:
															raise Exception("UNDERFLOW"		)

									snake_case   :			Tuple						    = self.array[self.front]
									snake_case   :			List[str]						    = None
									snake_case   :			Any						    = (self.front + 1) % self.n
									self.size -= 1
									return temp






from math import factorial, pi

def 			lowerCamelCase__			(       _a				,      _a = 30):

	if not isinstance(_a				,      (int, float)):
		raise ValueError("maclaurin_sin() requires either an int or float for theta")

	if not isinstance(_a				,      _a) or accuracy <= 0:
		raise ValueError("maclaurin_sin() requires a positive int for accuracy")

	SCREAMING_SNAKE_CASE :   int					  =							float(_a)
	SCREAMING_SNAKE_CASE :   Dict					  =							theta // (2 * pi)
	theta -= 2 * div * pi
	return sum(
	    (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1) for r in range(_a))

def 			lowerCamelCase__			(       _a				,      _a = 30):

	if not isinstance(_a				,      (int, float)):
		raise ValueError("maclaurin_cos() requires either an int or float for theta")

	if not isinstance(_a				,      _a) or accuracy <= 0:
		raise ValueError("maclaurin_cos() requires a positive int for accuracy")

	SCREAMING_SNAKE_CASE :   str					  =							float(_a)
	SCREAMING_SNAKE_CASE :   Any					  =							theta // (2 * pi)
	theta -= 2 * div * pi
	return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r) for r in range(_a))


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			print(maclaurin_sin(10))
			print(maclaurin_sin(-10))
			print(maclaurin_sin(10, 15))
			print(maclaurin_sin(-10, 15))

			print(maclaurin_cos(5))
			print(maclaurin_cos(-5))
			print(maclaurin_cos(10, 15))
			print(maclaurin_cos(-10, 15))