

"""simple docstring"""





import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
   import transformer_engine.pytorch as te




def     _A    (    UpperCamelCase_	:			Optional[Any],     UpperCamelCase_	:			Any=True,     UpperCamelCase_	:			str=True,     UpperCamelCase_	:			Any=True)      ->		List[Any]:
   '''simple docstring'''


   if not is_fpa_available():
      raise ImportError("Using `convert_model` requires transformer_engine to be installed.")
   for name, module in model.named_children():
      if isinstance(UpperCamelCase_,     nn.Linear) and to_transformer_engine and _convert_linear:
         # Return early if the linear layer weights are not multiples of 16
         if any(p % 16 != 0 for p in module.weight.shape):
            return
         __lowercase								=		module.bias is not None
         __lowercase								=		te.Linear(
             module.in_features,     module.out_features,     bias=UpperCamelCase_,     params_dtype=module.weight.dtype)
         __lowercase								=		module.weight.data.clone()
         if has_bias:
            __lowercase								=		module.bias.data.clone()

         setattr(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_)
      elif isinstance(UpperCamelCase_,     nn.LayerNorm) and to_transformer_engine and _convert_ln:
         __lowercase								=		te.LayerNorm(module.normalized_shape[0],     eps=module.eps,     params_dtype=module.weight.dtype)
         __lowercase								=		module.weight.data.clone()
         __lowercase								=		module.bias.data.clone()

         setattr(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_)
      elif isinstance(UpperCamelCase_,     te.Linear) and not to_transformer_engine and _convert_linear:
         __lowercase								=		module.bias is not None
         __lowercase								=		nn.Linear(
             module.in_features,     module.out_features,     bias=UpperCamelCase_,     params_dtype=module.weight.dtype)
         __lowercase								=		module.weight.data.clone()
         if has_bias:
            __lowercase								=		module.bias.data.clone()

         setattr(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_)
      elif isinstance(UpperCamelCase_,     te.LayerNorm) and not to_transformer_engine and _convert_ln:
         __lowercase								=		nn.LayerNorm(module.normalized_shape[0],     eps=module.eps,     params_dtype=module.weight.dtype)
         __lowercase								=		module.weight.data.clone()
         __lowercase								=		module.bias.data.clone()

         setattr(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_)
      else:
         convert_model(
             UpperCamelCase_,     to_transformer_engine=UpperCamelCase_,     _convert_linear=_convert_linear,     _convert_ln=_convert_ln,     )




def     _A    (    UpperCamelCase_	:			Dict)      ->		List[Any]:
   '''simple docstring'''


   if not is_fpa_available():
      raise ImportError("Using `has_transformer_engine_layers` requires transformer_engine to be installed.")
   for m in model.modules():
      if isinstance(UpperCamelCase_,     (te.LayerNorm, te.Linear)):
         return True
   return False







"""simple docstring"""





def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int = 1000)      ->		str:
   '''simple docstring'''


   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
   __lowercase								=		(
       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     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int,     UpperCamelCase_	:			int)      ->		float:
   '''simple docstring'''


   __lowercase								=		0.0
   for sum_index in range(digit_pos_to_extract + precision):
      __lowercase								=		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
         __lowercase								=		pow(
             16,     digit_pos_to_extract - 1 - sum_index,     UpperCamelCase_)
      else:
         __lowercase								=		pow(16,     digit_pos_to_extract - 1 - sum_index)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
   import doctest

   doctest.testmod()




