



"""simple docstring"""
import csv
import json
import os

import datasets


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
__a     =    "\\n@InProceedings{huggingface:dataset,\ntitle = {A great new dataset},\nauthor={huggingface, Inc.\n},\nyear={2020}\n}\n"

# TODO: Add description of the dataset here
# You can copy an official description
__a     =    "\\nThis new dataset is designed to solve this great NLP task and is crafted with a lot of care.\n"

# TODO: Add a link to an official homepage for the dataset here
__a     =    ""

# TODO: Add the licence for the dataset here if you can find it
__a     =    ""

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
__a     =    {
    "first_domain": "https://huggingface.co/great-new-dataset-first_domain.zip",
    "second_domain": "https://huggingface.co/great-new-dataset-second_domain.zip",
}
class     lowerCamelCase  (      datasets.GeneratorBasedBuilder    ):






					'''simple docstring'''





					_A		:      Optional[int]						=					datasets.Version("""1.1.0"""    )

					# This is an example of a dataset with multiple configurations.
					# If you don't want/need to define several sub-sets in your dataset,
					# just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

					# If you need to make complex sub-parts in the datasets with configurable options
					# You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
					# BUILDER_CONFIG_CLASS = MyBuilderConfig

					# You will be able to load one or the other configurations in the following list with
					# data = datasets.load_dataset('my_dataset', 'first_domain')
					# data = datasets.load_dataset('my_dataset', 'second_domain')
					_A		:      List[str]						=					[
					    datasets.BuilderConfig(name="""first_domain"""   ,						version=_lowerCAmelCase   ,						description="""This part of my dataset covers a first domain"""    ),
					    datasets.BuilderConfig(name="""second_domain"""   ,						version=_lowerCAmelCase   ,						description="""This part of my dataset covers a second domain"""    ),
					]

					_A		:      Dict						=					"""first_domain"""  # It's not mandatory to have a default configuration. Just use one if it make sense.






					def        lowerCAmelCase_    (	self:							str						)       ->     List[str]:
											# TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
											if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
																	snake_case_			:Optional[int]						=      datasets.Features(
																	    {
																	        """sentence""": datasets.Value("""string"""						),
																	        """option1""": datasets.Value("""string"""						),
																	        """answer""": datasets.Value("""string"""						)
																	        # These are the features of your dataset like images, labels ...
																	    }						)
											else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
																	snake_case_			:str						=      datasets.Features(
																	    {
																	        """sentence""": datasets.Value("""string"""						),
																	        """option2""": datasets.Value("""string"""						),
																	        """second_domain_answer""": datasets.Value("""string"""						)
																	        # These are the features of your dataset like images, labels ...
																	    }						)
											return datasets.DatasetInfo(
											    # This is the description that will appear on the datasets page.
											    description=_DESCRIPTION						,					features=snake_case						,					homepage=_HOMEPAGE						,					license=_LICENSE						,					citation=_CITATION						,					)






					def        lowerCAmelCase_    (	self:							Union[str, Any]						,					snake_case:							Optional[Any]						)       ->     Optional[Any]:
											# TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
											# If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name

											# dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
											# It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
											# By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
											snake_case_			:Optional[Any]						=      _URLS[self.config.name]
											snake_case_			:Union[str, Any]						=      dl_manager.download_and_extract(snake_case						)
											return [
											    datasets.SplitGenerator(
											        name=datasets.Split.TRAIN						,					gen_kwargs={
											            """filepath""": os.path.join(snake_case						,					"""train.jsonl"""						),
											            """split""": """train""",
											        }						,					),
											    datasets.SplitGenerator(
											        name=datasets.Split.VALIDATION						,					gen_kwargs={
											            """filepath""": os.path.join(snake_case						,					"""dev.jsonl"""						),
											            """split""": """dev""",
											        }						,					),
											    datasets.SplitGenerator(
											        name=datasets.Split.TEST						,					gen_kwargs={
											            """filepath""": os.path.join(snake_case						,					"""test.jsonl"""						),
											            """split""": """test"""
											        }						,					),
											]






					def        lowerCAmelCase_    (	self:							Optional[Any]						,					snake_case:							Optional[Any]						,					snake_case:							Any						)       ->     str:
											# TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
											# The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
											with open(snake_case						,					encoding="""utf-8"""						) as f:
																	for key, row in enumerate(snake_case						):
																							snake_case_			:str						=      json.loads(snake_case						)
																							if self.config.name == "first_domain":
																													# Yields examples as (key, example) tuples
																													yield key, {
																													    "sentence": data["sentence"],
																													    "option1": data["option1"],
																													    "answer": "" if split == "test" else data["answer"],
																													}
																							else:
																													yield key, {
																													    "sentence": data["sentence"],
																													    "option2": data["option2"],
																													    "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
																													}





"""simple docstring"""
from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
__a     =    9.8_06_65
def        A_  (      _lowercase, _lowercase     ):







						'''simple docstring'''


						if not isinstance(_lowercase, (int, float)     ):
												raise TypeError("""Invalid velocity. Should be a positive number."""     )

						if not isinstance(_lowercase, (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        A_  (      _lowercase, _lowercase     ):







						'''simple docstring'''


						check_args(_lowercase, _lowercase     )
						snake_case_			:str						=      angle_to_radians(2 * angle     )
						return round(init_velocity**2 * sin(_lowercase     ) / g, 2     )
def        A_  (      _lowercase, _lowercase     ):







						'''simple docstring'''


						check_args(_lowercase, _lowercase     )
						snake_case_			:str						=      angle_to_radians(_lowercase     )
						return round(init_velocity**2 * sin(_lowercase     ) ** 2 / (2 * g), 2     )
def        A_  (      _lowercase, _lowercase     ):







						'''simple docstring'''


						check_args(_lowercase, _lowercase     )
						snake_case_			:Optional[int]						=      angle_to_radians(_lowercase     )
						return round(2 * init_velocity * sin(_lowercase     ) / g, 2     )
def        A_  (      ):







						'''simple docstring'''


						snake_case_,	snake_case_			:List[str]						=      25, 20
						assert horizontal_distance(_lowercase, _lowercase     ) == 40.97
						assert max_height(_lowercase, _lowercase     ) == 3.73
						assert total_time(_lowercase, _lowercase     ) == 1.74


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

						testmod()

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

						# Get input from user
						__a     =    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]""")
