
"""simple docstring"""






from .stack import Stack
def    UpperCamelCase						(					UpperCAmelCase     )						->bool:

   """simple docstring"""



   a_						   =     Stack()
   a_						   =     {"(": ")", "[": "]", "{": "}"}
   for bracket in parentheses:
      if bracket in bracket_pairs:
         stack.push(UpperCAmelCase     )
      elif bracket in (")", "]", "}"):
         if stack.is_empty() or bracket_pairs[stack.pop()] != bracket:
            return False
   return stack.is_empty()


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      UpperCamelCase_						   =   ['((()))', '((())', '(()))']
      print('Balanced parentheses demonstration:\n')
      for example in examples:
            UpperCamelCase_						   =   '' if balanced_parentheses(example) else 'not '
            print(F"""{example} is {not_str}balanced""")

"""simple docstring"""






def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase = 1_000     )						->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
   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    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase     )						->float:

   """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 ,   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()