
def     A__   (  lowerCamelCase  )					->		float:
				return 10 - x * x







def     A__   (  lowerCamelCase       ,      lowerCamelCase  )					->		float:
				# Bolzano theory in order to find if there is a root between a and b
				if equation(lowerCamelCase  ) * equation(lowerCamelCase  ) >= 0:
								raise ValueError("""Wrong space!"""  )

				UpperCamelCase_:							Any		=  a
				while (b - a) >= 0.01:
								# Find middle point
								UpperCamelCase_:							Optional[Any]		=  (a + b) / 2
								# Check if middle point is root
								if equation(lowerCamelCase  ) == 0.0:
												break
								# Decide the side to repeat the steps
								if equation(lowerCamelCase  ) * equation(lowerCamelCase  ) < 0:
												UpperCamelCase_:							List[Any]		=  c
								else:
												UpperCamelCase_:							List[str]		=  c
				return c


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							print(bisection(-2, 5))
							print(bisection(0, 6))








import json
import os
import unittest

from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin

class     _UpperCamelCase			(   _A       ,    unittest.TestCase					):






			'''simple docstring'''

			__UpperCamelCase :  Tuple    =	CTRLTokenizer
			__UpperCamelCase :  int    =	False
			__UpperCamelCase :  List[str]    =	False

			def  lowerCAmelCase__		(    self	:    List[str] ):
							super().setUp()

							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
							UpperCamelCase_:							int		=  ["""adapt""", """re@@""", """a@@""", """apt""", """c@@""", """t""", """<unk>"""]
							UpperCamelCase_:							int		=  dict(zip(snake_case_  ,		range(len(snake_case_ ) ) ) )
							UpperCamelCase_:							Union[str, Any]		=  ["""#version: 0.2""", """a p""", """ap t</w>""", """r e""", """a d""", """ad apt</w>""", """"""]
							UpperCamelCase_:							Tuple		=  {"""unk_token""": """<unk>"""}

							UpperCamelCase_:							Optional[Any]		=  os.path.join(self.tmpdirname  ,		VOCAB_FILES_NAMES["""vocab_file"""] )
							UpperCamelCase_:							Dict		=  os.path.join(self.tmpdirname  ,		VOCAB_FILES_NAMES["""merges_file"""] )
							with open(self.vocab_file  ,		"""w"""  ,		encoding="""utf-8""" ) as fp:
											fp.write(json.dumps(snake_case_ ) + """\n""" )
							with open(self.merges_file  ,		"""w"""  ,		encoding="""utf-8""" ) as fp:
											fp.write("""\n""".join(snake_case_ ) )

			def  lowerCAmelCase__		(    self	:    Optional[int]  ,		**snake_case_	:    int ):
							kwargs.update(self.special_tokens_map )
							return CTRLTokenizer.from_pretrained(self.tmpdirname  ,		**snake_case_ )

			def  lowerCAmelCase__		(    self	:    Optional[int]  ,		snake_case_	:    List[str] ):
							UpperCamelCase_:							Dict		=  """adapt react readapt apt"""
							UpperCamelCase_:							List[str]		=  """adapt react readapt apt"""
							return input_text, output_text




			def  lowerCAmelCase__		(    self	:    List[str] ):
							UpperCamelCase_:							str		=  CTRLTokenizer(self.vocab_file  ,		self.merges_file  ,		**self.special_tokens_map )
							UpperCamelCase_:							List[Any]		=  """adapt react readapt apt"""
							UpperCamelCase_:							Optional[int]		=  """adapt re@@ a@@ c@@ t re@@ adapt apt""".split()
							UpperCamelCase_:							int		=  tokenizer.tokenize(snake_case_ )
							self.assertListEqual(snake_case_  ,		snake_case_ )

							UpperCamelCase_:							List[Any]		=  tokens + [tokenizer.unk_token]

							UpperCamelCase_:							Union[str, Any]		=  [0, 1, 2, 4, 5, 1, 0, 3, 6]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_ )  ,		snake_case_ )






