docs: def _format_to_fixed_precision(self, precision):
          """ Format 'self' to a given number of digits after the decimal point.
  
          Returns a triple (negative, digits, exp) where:
  
            - negative is a boolean, True for a negative number, else False
            - digits is a string giving the digits of the output
            - exp represents the exponent of the output
  
          The normalization of the exponent is such that <digits>E<exp>
          represents the decimal approximation to self.
  
          """
          # MPFR only provides functions to format to a given number of
          # significant digits.  So we must:
          #
          #   (1) Identify an e such that 10**(e-1) <= abs(x) < 10**e.
          #
          #   (2) Determine the number of significant digits required, and format
          #       to that number of significant digits.
          #
          #   (3) Adjust output if necessary if it's been rounded up to 10**e.
  
          # Zeros
          if is_zero(self):
              return is_negative(self), '0', -precision
  
          # Specials
          if is_inf(self):
              return is_negative(self), 'inf', None
  
          if is_nan(self):
              return is_negative(self), 'nan', None
  
          # Figure out the exponent by making a call to get_str2.  exp satisfies
          # 10**(exp-1) <= self < 10**exp
          _, _, exp = _mpfr_get_str2(
              10,
              2,
              self,
              ROUND_TOWARD_ZERO,
          )
  
          sig_figs = exp + precision
  
          if sig_figs < 0:
              sign = self._sign()
              return sign, '0', -precision
  
          elif sig_figs == 0:
              # Ex: 0.1 <= x < 1.0, rounding x to nearest multiple of 1.0.
              # Or: 100.0 <= x < 1000.0, rounding x to nearest multiple of 1000.0
              sign, digits, new_exp = _mpfr_get_str2(
                  10,
                  2,
                  self,
                  ROUND_TOWARD_NEGATIVE,
              )
              if int(digits) == 50:
                  # Halfway case
                  sign, digits, new_exp = _mpfr_get_str2(
                      10,
                      2,
                      self,
                      ROUND_TOWARD_POSITIVE,
                  )
  
              digits = '1' if int(digits) > 50 or new_exp == exp + 1 else '0'
              return sign, digits, -precision
  
          negative, digits, new_exp = self._format_to_floating_precision(
              sig_figs
          )
  
          # It's possible that the rounding up involved changes the exponent;
          # in that case we have to adjust the digits accordingly.  The only
          # possibility should be that new_exp == exp + 1.
          if new_exp + len(digits) != exp:
              assert new_exp + len(digits) == exp + 1
              digits += '0'
  
          return negative, digits, -precision