code: public float floatValue(){
          if(intCompact != INFLATED) {
              if (scale == 0) {
                  return (float)intCompact;
              } else {
                  /*
                   * If both intCompact and the scale can be exactly
                   * represented as float values, perform a single float
                   * multiply or divide to compute the (properly
                   * rounded) result.
                   */
                  if (Math.abs(intCompact) < 1L<<22 ) {
                      // Don't have too guard against
                      // Math.abs(MIN_VALUE) because of outer check
                      // against INFLATED.
                      if (scale > 0 && scale < float10pow.length) {
                          return (float)intCompact / float10pow[scale];
                      } else if (scale < 0 && scale > -float10pow.length) {
                          return (float)intCompact * float10pow[-scale];
                      }
                  }
              }
          }
          // Somewhat inefficient, but guaranteed to work.
          return Float.parseFloat(this.toString());
      }
docs: Converts this {@code BigDecimal} to a {@code float}.
  This conversion is similar to the
  <i>narrowing primitive conversion</i> from {@code double} to
  {@code float} as defined in section 5.1.3 of
  <cite>The Java&trade; Language Specification</cite>:
  if this {@code BigDecimal} has too great a
  magnitude to represent as a {@code float}, it will be
  converted to {@link Float#NEGATIVE_INFINITY} or {@link
  Float#POSITIVE_INFINITY} as appropriate.  Note that even when
  the return value is finite, this conversion can lose
  information about the precision of the {@code BigDecimal}
  value.
  
  @return this {@code BigDecimal} converted to a {@code float}.