



def       A_   (						__a  :					int			,		__a  :					int = 1_000		):

				"""simple docstring"""
				if (not isinstance(__a			,		__a		)) or (digit_position <= 0):
								raise ValueError("""Digit position must be a positive integer"""		)
				elif (not isinstance(__a			,		__a		)) or (precision < 0):
								raise ValueError("""Precision must be a nonnegative integer"""		)

				# compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
				# accurate
				a__					   =		(
				    4 * _subsum(__a			,		1			,		__a		)
				    - 2 * _subsum(__a			,		4			,		__a		)
				    - _subsum(__a			,		5			,		__a		)
				    - _subsum(__a			,		6			,		__a		)
				)

				# return the first hex digit of the fractional part of the result
				return hex(int((sum_result % 1) * 16		)		)[2:]

def       A_   (						__a  :					int			,		__a  :					int			,		__a  :					int		):

				"""simple docstring"""
				a__					   =		0.0
				for sum_index in range(digit_pos_to_extract + precision		):
								a__					   =		8 * sum_index + denominator_addend
								if sum_index < digit_pos_to_extract:
												# if the exponential term is an integer and we mod it by the denominator
												# before dividing, only the integer part of the sum will change;
												# the fractional part will not
												a__					   =		pow(
												    16			,		digit_pos_to_extract - 1 - sum_index			,		__a		)
								else:
												a__					   =		pow(16			,		digit_pos_to_extract - 1 - sum_index		)
								total += exponential_term / denominator
				return total


if __name__ == "__main__":
	import doctest

	doctest.testmod()


"""simple docstring"""


from typing import TYPE_CHECKING

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


__A       			=      {
    """configuration_realm""": ["""REALM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RealmConfig"""],
    """tokenization_realm""": ["""RealmTokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       			=      ["""RealmTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       			=      [
     """REALM_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """RealmEmbedder""",
     """RealmForOpenQA""",
     """RealmKnowledgeAugEncoder""",
     """RealmPreTrainedModel""",
     """RealmReader""",
     """RealmScorer""",
     """load_tf_weights_in_realm""",
 ]
 __A       			=      ["""RealmRetriever"""]


if TYPE_CHECKING:
 from .configuration_realm import REALM_PRETRAINED_CONFIG_ARCHIVE_MAP, RealmConfig
 from .tokenization_realm import RealmTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_realm import RealmTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_realm import (
      REALM_PRETRAINED_MODEL_ARCHIVE_LIST,
      RealmEmbedder,
      RealmForOpenQA,
      RealmKnowledgeAugEncoder,
      RealmPreTrainedModel,
      RealmReader,
      RealmScorer,
      load_tf_weights_in_realm,
  )
  from .retrieval_realm import RealmRetriever


else:
 import sys

 __A       			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
