updateBound)}),t.updateBound=null,t.scrollParents=[],t.scrollElement=null,t.eventsEnabled=!1,t}function U(){this.state.eventsEnabled&&(cancelAnimationFrame(this.scheduleUpdate),this.state=R(this.reference,this.state))}function Y(e){return''!==e&&!isNaN(parseFloat(e))&&isFinite(e)}function V(e,t){Object.keys(t).forEach(function(o){var n='';-1!==['width','height','top','right','bottom','left'].indexOf(o)&&Y(t[o])&&(n='px'),e.style[o]=t[o]+n})}function j(e,t){Object.keys(t).forEach(function(o){var ...

        // copySign(x, 1.0) is a branch-free version of abs(x), but with different NaN semantics
        || (a == b) // needed to ensure that infinities equal themselves
        || (Double.isNaN(a) && Double.isNaN(b));
  }

  /**
   * Compares {@code a} and {@code b} "fuzzily," with a tolerance for nearly-equal values.
   *

      assertTrue(Double.isNaN(DoubleMath.log2(-d)));
    }
  }

  public void testLog2Zero() {
    assertThat(DoubleMath.log2(0.0)).isNegativeInfinity();
    assertThat(DoubleMath.log2(-0.0)).isNegativeInfinity();
  }

  public void testLog2NaNInfinity() {
    assertThat(DoubleMath.log2(Double.POSITIVE_INFINITY)).isPositiveInfinity();
    assertTrue(Double.isNaN(DoubleMath.log2(Double.NEGATIVE_INFINITY)));

a,s=t;for("string"==typeof e&&(e=[e]),m(t)&&(s=function(e,a){a[t]=G(e)}),a=0;a<e.length;a++)ce[e[a]]=s}function Ye(e,n){Le(e,function(e,a,t,s){t._w=t._w||{},n(e,t._w,t,s)})}var ye,fe=0,pe=1,ke=2,De=3,Te=4,ge=5,we=6,ve=7,be=8;function Se(e,a){if(isNaN(e)||isNaN(a))return NaN;var t,s=(a%(t=12)+t)%t;return e+=(a-s)/12,1==s?I(e)?29:28:31-s%7%2}ye=Array.prototype.indexOf?Array.prototype.indexOf:function(e){for(var a=0;a<this.length;++a)if(this[a]===e)return a;return-1},W("M",["MM",2],"Mo",function(){return...

      assertTrue(Double.isNaN(DoubleMath.log2(-d)));
    }
  }

  public void testLog2Zero() {
    assertThat(DoubleMath.log2(0.0)).isNegativeInfinity();
    assertThat(DoubleMath.log2(-0.0)).isNegativeInfinity();
  }

  public void testLog2NaNInfinity() {
    assertThat(DoubleMath.log2(Double.POSITIVE_INFINITY)).isPositiveInfinity();
    assertTrue(Double.isNaN(DoubleMath.log2(Double.NEGATIVE_INFINITY)));

        format(builder, size, unit, false);
    }

    public void formatRate(MessageBuilder builder, double rate) {
        // Handle invalid rates gracefully (including negative values)
        if (Double.isNaN(rate) || Double.isInfinite(rate) || rate < 0) {
            builder.append("? B/s");
            return;
        }

        ScaleUnit unit = ScaleUnit.getScaleUnit(Math.round(rate));

     * the transformation is vertical. (If it is zero, the transformation is horizontal.)
     */
    public LinearTransformation withSlope(double slope) {
      checkArgument(!Double.isNaN(slope));
      if (isFinite(slope)) {
        double yIntercept = y1 - x1 * slope;
        return new RegularLinearTransformation(slope, yIntercept);
      } else {
        return new VerticalLinearTransformation(x1);

    assertThat(max(-0.0, 0.0)).isEqualTo(0.0);
    assertThat(max(0.0, -0.0)).isEqualTo(0.0);
    assertThat(max(NUMBERS)).isEqualTo(GREATEST);
    assertThat(Double.isNaN(max(VALUES))).isTrue();
  }

  @GwtIncompatible
  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {

        // Test with special numeric values
        OptionalEntity<Double> nanOpt = OptionalUtil.ofNullable(Double.NaN);
        assertTrue(nanOpt.isPresent());
        assertTrue(Double.isNaN(nanOpt.get()));

        OptionalEntity<Double> infinityOpt = OptionalUtil.ofNullable(Double.POSITIVE_INFINITY);
        assertTrue(infinityOpt.isPresent());
        assertTrue(Double.isInfinite(infinityOpt.get()));

    assertThat(max(-0.0, 0.0)).isEqualTo(0.0);
    assertThat(max(0.0, -0.0)).isEqualTo(0.0);
    assertThat(max(NUMBERS)).isEqualTo(GREATEST);
    assertThat(Double.isNaN(max(VALUES))).isTrue();
  }

  @GwtIncompatible
  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {