



from math import radians as angle_to_radians
from math import sin

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


def       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):

		# 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 > 90 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       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):
		check_args(__UpperCamelCase					,__UpperCamelCase			)
		lowerCAmelCase_      :					Optional[Any]     =			angle_to_radians(2 * angle			)
		return round(init_velocity**2 * sin(__UpperCamelCase			) / g					,2			)


def       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):
		check_args(__UpperCamelCase					,__UpperCamelCase			)
		lowerCAmelCase_      :					Any     =			angle_to_radians(__UpperCamelCase			)
		return round(init_velocity**2 * sin(__UpperCamelCase			) ** 2 / (2 * g)					,2			)


def       UpperCamelCase(  __UpperCamelCase							:		float					,__UpperCamelCase							:		float			):
		check_args(__UpperCamelCase					,__UpperCamelCase			)
		lowerCAmelCase_      :					Dict     =			angle_to_radians(__UpperCamelCase			)
		return round(2 * init_velocity * sin(__UpperCamelCase			) / g					,2			)


def       UpperCamelCase(  ):
		lowerCAmelCase_ ,  lowerCAmelCase_      :					Any     =			25, 20
		assert horizontal_distance(__UpperCamelCase					,__UpperCamelCase			) == 4_0.9_7
		assert max_height(__UpperCamelCase					,__UpperCamelCase			) == 3.7_3
		assert total_time(__UpperCamelCase					,__UpperCamelCase			) == 1.7_4


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

						testmod()

						# Get input from user
						A__  :  List[Any]       = float(input('''Initial Velocity: ''').strip())

						# Get input from user
						A__  :  Dict       = 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]''')










import torch
import trajectory.utils as utils

from transformers import TrajectoryTransformerModel



class     __snake_case						(					utils.Parser						):
							_a      				=			"halfcheetah-medium-expert-v2"
							_a      				=			"config.offline"





def       UpperCamelCase(  __UpperCamelCase							:		List[Any]					,__UpperCamelCase							:		Any					,__UpperCamelCase							:		Tuple					,__UpperCamelCase							:		Optional[Any]					,__UpperCamelCase							:		List[Any]			):
		lowerCAmelCase_ ,  lowerCAmelCase_      :					Optional[Any]     =			utils.load_model(__UpperCamelCase					,__UpperCamelCase					,__UpperCamelCase					,epoch=__UpperCamelCase					,device=__UpperCamelCase			)
		lowerCAmelCase_      :					List[str]     =			TrajectoryTransformerModel(gpt.config			)

		trajectory_transformer.tok_emb.load_state_dict(gpt.tok_emb.state_dict()			)
		lowerCAmelCase_      :					str     =			gpt.pos_emb
		trajectory_transformer.drop.load_state_dict(gpt.drop.state_dict()			)
		trajectory_transformer.ln_f.load_state_dict(gpt.ln_f.state_dict()			)
		trajectory_transformer.head.load_state_dict(gpt.head.state_dict()			)

		for i, block in enumerate(gpt.blocks			):
				trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()			)
				trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()			)
				trajectory_transformer.blocks[i].attn.load_state_dict(gpt.blocks[i].attn.state_dict()			)

				trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[0].state_dict()			)
				trajectory_transformer.blocks[i].act.load_state_dict(gpt.blocks[i].mlp[1].state_dict()			)
				trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[2].state_dict()			)
				trajectory_transformer.blocks[i].drop.load_state_dict(gpt.blocks[i].mlp[3].state_dict()			)

		torch.save(trajectory_transformer.state_dict()					,'''pytorch_model.bin'''			)


if __name__ == "__main__":
						A__  :  Any       = Parser().parse_args('''plan''')
						convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch(
						    args.logbase, args.dataset, args.gpt_loadpath, args.gpt_epoch, args.device
						)





