code: def run_step(self):
      # We check for a bunch of standard "large" floats. If we're currently
      # worse than them and the shrink downwards doesn't help, abort early
      # because there's not much useful we can do here.
  
      # Finally we get to the important bit: Each of these is a small change
      # to the floating point number that corresponds to a large change in
      # the lexical representation. Trying these ensures that our floating
      # point shrink can always move past these obstacles. In particular it
      # ensures we can always move to integer boundaries and shrink past a
      # change that would require shifting the exponent while not changing
      # the float value much.
  
      for g in [math.floor(self.current), math.ceil(self.current)]:
          self.consider(g)
  
      if self.consider(int(self.current)):
          self.debug("Just an integer now")
          self.delegate(Integer, convert_to=int, convert_from=float)
          return
  
      m, n = self.current.as_integer_ratio()
      i, r = divmod(m, n)
  
      # Now try to minimize the top part of the fraction as an integer. This
      # basically splits the float as k + x with 0 <= x < 1 and minimizes
      # k as an integer, but without the precision issues that would have.
      self.call_shrinker(
          Integer, i, lambda k: self.consider((i * n + r) / n)
      )
  
file_path: catboost/contrib/python/hypothesis/py2/hypothesis/internal/conjecture/shrinking/floats.py
imports: from __future__ import absolute_import, division, print_function
  import math
  import sys
  from hypothesis.internal.conjecture.floats import float_to_lex
  from hypothesis.internal.conjecture.shrinking.common import Shrinker
  from hypothesis.internal.conjecture.shrinking.integer import Integer
label_desc: Use image node_id 6 for calling the Float obj's underlying member method code with example usage: obj.run_step() without return types