
"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case    =		{
    'configuration_markuplm': ['MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MarkupLMConfig'],
    'feature_extraction_markuplm': ['MarkupLMFeatureExtractor'],
    'processing_markuplm': ['MarkupLMProcessor'],
    'tokenization_markuplm': ['MarkupLMTokenizer'],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case    =		['MarkupLMTokenizerFast']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case    =		[
	    'MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'MarkupLMForQuestionAnswering',
	    'MarkupLMForSequenceClassification',
	    'MarkupLMForTokenClassification',
	    'MarkupLMModel',
	    'MarkupLMPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_markuplm import MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP, MarkupLMConfig
	from .feature_extraction_markuplm import MarkupLMFeatureExtractor
	from .processing_markuplm import MarkupLMProcessor
	from .tokenization_markuplm import MarkupLMTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_markuplm_fast import MarkupLMTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_markuplm import (
		    MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    MarkupLMForQuestionAnswering,
		    MarkupLMForSequenceClassification,
		    MarkupLMForTokenClassification,
		    MarkupLMModel,
		    MarkupLMPreTrainedModel,
		)


else:
	import sys

	snake_case    =		_LazyModule(__name__, globals()['__file__'], _import_structure)


"""simple docstring"""




snake_case    =		1_0_0_0

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_			):
					return x * x

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_ = 4			):
					assert callable(
					    SCREAMING_SNAKE_CASE_			), f'''the function(object) passed should be callable your input : {function}'''
					assert isinstance(SCREAMING_SNAKE_CASE_,     (float, int)			), f'''a should be float or integer your input : {a}'''
					assert isinstance(function(SCREAMING_SNAKE_CASE_			),     (float, int)			), (
					    "the function should return integer or float return type of your function, "
					    f'''{type(SCREAMING_SNAKE_CASE_			)}'''
					)
					assert isinstance(SCREAMING_SNAKE_CASE_,     (float, int)			), f'''b should be float or integer your input : {b}'''
					assert (
					    isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			) and precision > 0
					), f'''precision should be positive integer your input : {precision}'''

					# just applying the formula of simpson for approximate integration written in
					# mentioned article in first comment of this file and above this function

					SCREAMING_SNAKE_CASE				=	(b - a) / N_STEPS
					SCREAMING_SNAKE_CASE				=	function(SCREAMING_SNAKE_CASE_			) + function(SCREAMING_SNAKE_CASE_			)

					for i in range(1,     SCREAMING_SNAKE_CASE_			):
										SCREAMING_SNAKE_CASE				=	a + h * i
										result += function(SCREAMING_SNAKE_CASE_			) * (4 if i % 2 else 2)

					result *= h / 3
					return round(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
