






'''simple docstring'''







from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
UpperCamelCase_					=				9.8_0_6_6_5






def  lowerCAmelCase__		(					a_  :     Optional[int]			,						a_  :     Tuple			)   -> Any:

       # Ensure valid instance
       if not isinstance(_UpperCamelCase			,						(int, float)			):
              raise TypeError('''Invalid velocity. Should be a positive number.'''			)

       if not isinstance(_UpperCamelCase			,						(int, float)			):
              raise TypeError('''Invalid angle. Range is 1-90 degrees.'''			)

       # Ensure valid angle
       if angle > 9_0 or angle < 1:
              raise ValueError('''Invalid angle. Range is 1-90 degrees.'''			)

       # Ensure valid velocity
       if init_velocity < 0:
              raise ValueError('''Invalid velocity. Should be a positive number.'''			)






def  lowerCAmelCase__		(					a_  :     Union[str, Any]			,						a_  :     Any			)   -> Optional[int]:
       check_args(_UpperCamelCase			,						_UpperCamelCase			)
       UpperCAmelCase__	:   Union[str, Any]												=	angle_to_radians(2 * angle			)
       return round(init_velocity**2 * sin(_UpperCamelCase			) / g			,						2			)






def  lowerCAmelCase__		(					a_  :     Any			,						a_  :     Dict			)   -> Optional[int]:
       check_args(_UpperCamelCase			,						_UpperCamelCase			)
       UpperCAmelCase__	:   Tuple												=	angle_to_radians(_UpperCamelCase			)
       return round(init_velocity**2 * sin(_UpperCamelCase			) ** 2 / (2 * g)			,						2			)






def  lowerCAmelCase__		(					a_  :     Union[str, Any]			,						a_  :     Tuple			)   -> List[str]:
       check_args(_UpperCamelCase			,						_UpperCamelCase			)
       UpperCAmelCase__	:   Union[str, Any]												=	angle_to_radians(_UpperCamelCase			)
       return round(2 * init_velocity * sin(_UpperCamelCase			) / g			,						2			)






def  lowerCAmelCase__		(					)   -> Dict:
       UpperCAmelCase__	:   Optional[Any]												=	2_5, 2_0
       assert horizontal_distance(_UpperCamelCase			,						_UpperCamelCase			) == 40.97
       assert max_height(_UpperCamelCase			,						_UpperCamelCase			) == 3.73
       assert total_time(_UpperCamelCase			,						_UpperCamelCase			) == 1.74


if __name__ == "__main__":
  from doctest import testmod

  testmod()

  # Get input from user
  UpperCamelCase_					=				float(input("Initial Velocity: ").strip())

  # Get input from user
  UpperCamelCase_					=				float(input("angle: ").strip())

  # Print results
  print()
  print("Results: ")
  print(f'Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]')
  print(f'Maximum Height: {max_height(init_vel, angle)!s} [m]')
  print(f'Total Time: {total_time(init_vel, angle)!s} [s]')

"""simple docstring"""







import json
import os
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowerCamelCase__     =						logging.get_logger(__name__)

lowerCamelCase__     =						{
    """vocab_file""": """vocab.json""",
    """merges_file""": """merges.txt""",
}

lowerCamelCase__     =						{
    """vocab_file""": {
        """microsoft/biogpt""": """https://huggingface.co/microsoft/biogpt/resolve/main/vocab.json""",
    },
    """merges_file""": {"""microsoft/biogpt""": """https://huggingface.co/microsoft/biogpt/resolve/main/merges.txt"""},
}

lowerCamelCase__     =						{
    """microsoft/biogpt""": 1_024,
}
def        __lowerCAmelCase							(_UpperCamelCase						):
	__lowerCAmelCase     :		Tuple		     = set()
	__lowerCAmelCase     :		str		     = word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)						)
		__lowerCAmelCase     :		Optional[Any]		     = char
	return pairs




class 					A__			(      _lowerCamelCase):
		A_		:			Union[str, Any]							  =      VOCAB_FILES_NAMES
		A_		:			List[Any]							  =      PRETRAINED_VOCAB_FILES_MAP
		A_		:			Optional[Any]							  =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		A_		:			int							  =      ['input_ids', 'attention_mask']

		def __init__( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE="<unk>"			,						_SCREAMING_SNAKE_CASE="<s>"			,						_SCREAMING_SNAKE_CASE="</s>"			,						_SCREAMING_SNAKE_CASE="</s>"			,						_SCREAMING_SNAKE_CASE="<pad>"			,						**_SCREAMING_SNAKE_CASE			,						):
			super().__init__(
			    bos_token=_SCREAMING_SNAKE_CASE			,						eos_token=_SCREAMING_SNAKE_CASE			,						sep_token=_SCREAMING_SNAKE_CASE			,						unk_token=_SCREAMING_SNAKE_CASE			,						pad_token=_SCREAMING_SNAKE_CASE			,						**_SCREAMING_SNAKE_CASE			,						)

			try:
				import sacremoses
			except ImportError:
				raise ImportError(
				    'You need to install sacremoses to use BioGptTokenizer. '
				    'See https://pypi.org/project/sacremoses/ for installation.'					)

			__lowerCAmelCase     :		int		     = 'en'
			__lowerCAmelCase     :		Optional[Any]		     = sacremoses
			# cache of sm.MosesTokenizer instance
			__lowerCAmelCase     :		Optional[int]		     = {}
			__lowerCAmelCase     :		Any		     = {}
			with open(_SCREAMING_SNAKE_CASE			,						encoding='utf-8'					) as vocab_handle:
				__lowerCAmelCase     :		int		     = json.load(_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Any		     = {v: k for k, v in self.encoder.items()}
			with open(_SCREAMING_SNAKE_CASE			,						encoding='utf-8'					) as merges_handle:
				__lowerCAmelCase     :		Optional[int]		     = merges_handle.read().split('\n'					)[:-1]
			__lowerCAmelCase     :		Dict		     = [tuple(merge.split()[:2]					) for merge in merges]
			__lowerCAmelCase     :		Optional[Any]		     = dict(zip(_SCREAMING_SNAKE_CASE			,						range(len(_SCREAMING_SNAKE_CASE					)					)					)					)
			__lowerCAmelCase     :		Optional[int]		     = {}

		@property
		def 				__lowerCamelCase				( self					):
			return len(self.encoder					)

		def 				__lowerCamelCase				( self					):
			return dict(self.encoder			,						**self.added_tokens_encoder					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					):
			if lang not in self.cache_moses_tokenizer:
				__lowerCAmelCase     :		str		     = self.sm.MosesTokenizer(lang=_SCREAMING_SNAKE_CASE					)
				__lowerCAmelCase     :		Optional[int]		     = moses_tokenizer
			return self.cache_moses_tokenizer[lang].tokenize(
			    _SCREAMING_SNAKE_CASE			,						aggressive_dash_splits=_SCREAMING_SNAKE_CASE			,						return_str=_SCREAMING_SNAKE_CASE			,						escape=_SCREAMING_SNAKE_CASE					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					):
			if lang not in self.cache_moses_detokenizer:
				__lowerCAmelCase     :		Any		     = self.sm.MosesDetokenizer(lang=_SCREAMING_SNAKE_CASE					)
				__lowerCAmelCase     :		Any		     = moses_detokenizer
			return self.cache_moses_detokenizer[lang].detokenize(_SCREAMING_SNAKE_CASE					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			__lowerCAmelCase     :		List[Any]		     = tuple(token[:-1]					) + (token[-1] + '</w>',)
			if token in self.cache:
				return self.cache[token]
			__lowerCAmelCase     :		Union[str, Any]		     = get_pairs(_SCREAMING_SNAKE_CASE					)

			if not pairs:
				return token + "</w>"

			while True:
				__lowerCAmelCase     :		List[Any]		     = min(_SCREAMING_SNAKE_CASE			,						key=lambda _SCREAMING_SNAKE_CASE					: self.bpe_ranks.get(_SCREAMING_SNAKE_CASE			,						float('inf'					)					)					)
				if bigram not in self.bpe_ranks:
					break
				__lowerCAmelCase     ,  __lowerCAmelCase     :		str		     = bigram
				__lowerCAmelCase     :		Any		     = []
				__lowerCAmelCase     :		Optional[Any]		     = 0
				while i < len(_SCREAMING_SNAKE_CASE					):
					try:
						__lowerCAmelCase     :		Optional[Any]		     = word.index(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					)
					except ValueError:
						new_word.extend(word[i:]					)
						break
					else:
						new_word.extend(word[i:j]					)
						__lowerCAmelCase     :		int		     = j

					if word[i] == first and i < len(_SCREAMING_SNAKE_CASE					) - 1 and word[i + 1] == second:
						new_word.append(first + second					)
						i += 2
					else:
						new_word.append(word[i]					)
						i += 1
				__lowerCAmelCase     :		Optional[Any]		     = tuple(_SCREAMING_SNAKE_CASE					)
				__lowerCAmelCase     :		Optional[Any]		     = new_word
				if len(_SCREAMING_SNAKE_CASE					) == 1:
					break
				else:
					__lowerCAmelCase     :		Optional[Any]		     = get_pairs(_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Optional[int]		     = ' '.join(_SCREAMING_SNAKE_CASE					)
			if word == "\n  </w>":
				__lowerCAmelCase     :		Dict		     = '\n</w>'
			__lowerCAmelCase     :		Optional[int]		     = word
			return word

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE=False					):
			if bypass_tokenizer:
				__lowerCAmelCase     :		Any		     = text.split()
			else:
				__lowerCAmelCase     :		Union[str, Any]		     = self.moses_tokenize(_SCREAMING_SNAKE_CASE			,						self.lang					)

			__lowerCAmelCase     :		List[str]		     = []
			for token in text:
				if token:
					split_tokens.extend(list(self.bpe(_SCREAMING_SNAKE_CASE					).split(' '					)					)					)

			return split_tokens

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			return self.encoder.get(_SCREAMING_SNAKE_CASE			,						self.encoder.get(self.unk_token					)					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			return self.decoder.get(_SCREAMING_SNAKE_CASE			,						self.unk_token					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			__lowerCAmelCase     :		List[str]		     = [t.replace(' '			,						''					).replace('</w>'			,						' '					) for t in tokens]
			__lowerCAmelCase     :		List[Any]		     = ''.join(_SCREAMING_SNAKE_CASE					).split()
			# detokenize
			__lowerCAmelCase     :		int		     = self.moses_detokenize(_SCREAMING_SNAKE_CASE			,						self.lang					)
			return text

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None					):
			if token_ids_a is None:
				return [self.sep_token_id] + token_ids_a
			__lowerCAmelCase     :		Dict		     = [self.sep_token_id]
			return sep + token_ids_a + sep + token_ids_a

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = False					):
			if already_has_special_tokens:
				return super().get_special_tokens_mask(
				    token_ids_a=_SCREAMING_SNAKE_CASE			,						token_ids_a=_SCREAMING_SNAKE_CASE			,						already_has_special_tokens=_SCREAMING_SNAKE_CASE					)
			# no bos used in fairseq
			if token_ids_a is not None:
				return [1] + ([0] * len(_SCREAMING_SNAKE_CASE					)) + [1] + ([0] * len(_SCREAMING_SNAKE_CASE					))
			return [1] + ([0] * len(_SCREAMING_SNAKE_CASE					))

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None					):
			__lowerCAmelCase     :		int		     = [self.sep_token_id]

			# no bos used in fairseq
			if token_ids_a is None:
				return len(token_ids_a + sep					) * [0]
			return len(token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None					):
			if not os.path.isdir(_SCREAMING_SNAKE_CASE					):
				logger.error(f"Vocabulary path ({save_directory}) should be a directory"					)
				return
			__lowerCAmelCase     :		List[Any]		     = os.path.join(
			    _SCREAMING_SNAKE_CASE			,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']					)
			__lowerCAmelCase     :		List[str]		     = os.path.join(
			    _SCREAMING_SNAKE_CASE			,						(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file']					)

			with open(_SCREAMING_SNAKE_CASE			,						'w'			,						encoding='utf-8'					) as f:
				f.write(json.dumps(self.encoder			,						indent=2			,						sort_keys=_SCREAMING_SNAKE_CASE			,						ensure_ascii=_SCREAMING_SNAKE_CASE					) + '\n'					)

			__lowerCAmelCase     :		str		     = 0
			with open(_SCREAMING_SNAKE_CASE			,						'w'			,						encoding='utf-8'					) as writer:
				for bpe_tokens, token_index in sorted(self.bpe_ranks.items()			,						key=lambda _SCREAMING_SNAKE_CASE					: kv[1]					):
					if index != token_index:
						logger.warning(
						    f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
						    ' Please check that the tokenizer is not corrupted!'					)
						__lowerCAmelCase     :		List[Any]		     = token_index
					writer.write(' '.join(_SCREAMING_SNAKE_CASE					) + '\n'					)
					index += 1

			return vocab_file, merge_file

		def __getstate__( self					):
			__lowerCAmelCase     :		Any		     = self.__dict__.copy()
			__lowerCAmelCase     :		List[str]		     = None
			return state







		def __setstate__( self			,						_SCREAMING_SNAKE_CASE					):
			__lowerCAmelCase     :		List[str]		     = d

			try:
				import sacremoses
			except ImportError:
				raise ImportError(
				    'You need to install sacremoses to use XLMTokenizer. '
				    'See https://pypi.org/project/sacremoses/ for installation.'					)

			__lowerCAmelCase     :		int		     = sacremoses