if (o == null) {
            return null;
        } else if (o instanceof Double) {
            return (Double) o;
        } else if (o instanceof Number) {
            return Double.valueOf(((Number) o).doubleValue());
        } else if (o instanceof String) {
            return toDouble((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

  }

  public void testDoubleValue() {
    for (int value : TEST_INTS) {
      UnsignedInteger unsignedValue = UnsignedInteger.fromIntBits(value);
      assertThat(unsignedValue.doubleValue())
          .isEqualTo(unsignedValue.bigIntegerValue().doubleValue());
    }
  }

  public void testPlus() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);

  @Override
  public float floatValue() {
    return (float) sum();
  }

  /** Returns the {@link #sum} as a {@code double} after a widening primitive conversion. */
  @Override
  public double doubleValue() {
    return (double) sum();
  }

  private void writeObject(ObjectOutputStream s) throws IOException {
    s.defaultWriteObject();
    s.writeLong(sum());
  }

    for (int i = 0, n = 0; n <= DoubleMath.MAX_FACTORIAL; i++, n += 16) {
      assertThat(DoubleMath.everySixteenthFactorial[i])
          .isEqualTo(BigIntegerMath.factorial(n).doubleValue());
    }
  }

  @GwtIncompatible // DoubleMath.roundToInt(double, RoundingMode)
  public void testRoundIntegralDoubleToInt() {
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {

        Iterables.filter(
            FINITE_DOUBLE_CANDIDATES,
            new Predicate<Double>() {
              @Override
              public boolean apply(Double input) {
                return input.doubleValue() > 0.0;
              }
            });
    DOUBLE_CANDIDATES_EXCEPT_NAN = Iterables.concat(FINITE_DOUBLE_CANDIDATES, INFINITIES);

   * Returns the value of this {@code UnsignedInteger} as a {@code double}, analogous to a widening
   * primitive conversion from {@code int} to {@code double}, and correctly rounded.
   */
  @Override
  public double doubleValue() {
    return longValue();
  }

  /** Returns the value of this {@code UnsignedInteger} as a {@link BigInteger}. */
  public BigInteger bigIntegerValue() {
    return BigInteger.valueOf(longValue());
  }

        } else if (value instanceof Long || value instanceof Integer) {
            buf.append(((Number) value).longValue());
        } else if (value instanceof Number) {
            buf.append(((Number) value).doubleValue());
        } else {
            buf.append('"').append(StringEscapeUtils.escapeJson(value.toString())).append('"');
        }
        return buf;
    }

    /**

    reverse(array, fromIndex, toIndex);
  }

  /**
   * Returns an array containing each value of {@code collection}, converted to a {@code double}
   * value in the manner of {@link Number#doubleValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *

                }
            } else if (doubleFieldSet.contains(key)) {
                if (value instanceof final Number num) {
                    value = num.doubleValue();
                } else {
                    value = DfTypeUtil.toDouble(value.toString());
                }
            }
            return new Pair<>(key, value);