



"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase__			=   {"configuration_umt5": ["UMT5Config", "UMT5OnnxConfig"]}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowerCamelCase__			=   [
          "UMT5EncoderModel",
          "UMT5ForConditionalGeneration",
          "UMT5ForQuestionAnswering",
          "UMT5Model",
          "UMT5PreTrainedModel",
      ]

if TYPE_CHECKING:
      from .configuration_umta import UMTaConfig, UMTaOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_umta import (
                UMTaEncoderModel,
                UMTaForConditionalGeneration,
                UMTaForQuestionAnswering,
                UMTaModel,
                UMTaPreTrainedModel,
            )
else:
      import sys

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












"""simple docstring"""




def 						_SCREAMING_SNAKE_CASE							( UpperCamelCase     :	int		,				UpperCamelCase     :	int = 1000    ):
  if (not isinstance(UpperCamelCase		,				UpperCamelCase    )) or (digit_position <= 0):
    raise ValueError("""Digit position must be a positive integer"""    )
  elif (not isinstance(UpperCamelCase		,				UpperCamelCase    )) 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(UpperCamelCase		,				1		,				UpperCamelCase    )
      - 2 * _subsum(UpperCamelCase		,				4		,				UpperCamelCase    )
      - _subsum(UpperCamelCase		,				5		,				UpperCamelCase    )
      - _subsum(UpperCamelCase		,				6		,				UpperCamelCase    )
  )

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






def 						_SCREAMING_SNAKE_CASE							( UpperCamelCase     :	int		,				UpperCamelCase     :	int		,				UpperCamelCase     :	int    ):
  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		,				UpperCamelCase    )
    else:
      A__											=							pow(16		,				digit_pos_to_extract - 1 - sum_index    )
    total += exponential_term / denominator
  return total


if __name__ == "__main__":
      import doctest

      doctest.testmod()




