code: public TolerantFloatComparison isNotWithin(final float tolerance) {
      return new TolerantFloatComparison() {
        @Override
        public void of(float expected) {
          Float actual = actual();
          checkNotNull(
              actual, "actual value cannot be null. tolerance=%s expected=%s", tolerance, expected);
          checkTolerance(tolerance);
  
          if (!notEqualWithinTolerance(actual, expected, tolerance)) {
            failWithoutActual(
                fact("expected not to be", floatToString(expected)),
                butWas(),
                fact("within tolerance", floatToString(tolerance)));
          }
        }
      };
    }
docs: Prepares for a check that the subject is a finite number not within the given tolerance of an
  expected value that will be provided in the next call in the fluent chain.
  
  <p>The check will fail if either the subject or the object is {@link Float#POSITIVE_INFINITY},
  {@link Float#NEGATIVE_INFINITY}, or {@link Float#NaN}. See {@link #isFinite}, {@link
  #isNotNaN}, or {@link #isNotEqualTo} for checks with other behaviours.
  
  <p>The check will fail if both values are zero, even if one is {@code 0.0f} and the other is
  {@code -0.0f}. Use {@code #isNotEqualTo} for a test which fails for a value of exactly zero
  with one sign but passes for zero with the opposite sign.
  
  <p>You can use a tolerance of {@code 0.0f} to assert the exact non-equality of finite floats,
  but sometimes {@link #isNotEqualTo} is preferable (note the different behaviours around
  non-finite values and {@code -0.0f}).
  
  @param tolerance an exclusive lower bound on the difference between the subject and object
  allowed by the check, which must be a non-negative finite value, i.e. not {@code
  Float.NaN}, {@code Float.POSITIVE_INFINITY}, or negative, including {@code -0.0f}