summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/library/scala/math/BigDecimal.scala479
-rw-r--r--src/library/scala/math/BigInt.scala2
-rw-r--r--test/files/jvm/bigints.scala1
-rw-r--r--test/files/run/bigDecimalTest.check2
-rw-r--r--test/files/run/is-valid-num.scala28
-rw-r--r--test/files/run/numbereq.scala27
-rw-r--r--test/junit/scala/math/BigDecimalTest.scala225
7 files changed, 674 insertions, 90 deletions
diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala
index d783dd29f5..bcbed645a7 100644
--- a/src/library/scala/math/BigDecimal.scala
+++ b/src/library/scala/math/BigDecimal.scala
@@ -16,36 +16,165 @@ import scala.collection.immutable.NumericRange
import scala.language.implicitConversions
-/**
+/**
* @author Stephane Micheloud
- * @version 1.0
+ * @author Rex Kerr
+ * @version 1.1
* @since 2.7
*/
object BigDecimal {
+ private final val maximumHashScale = 4934 // Quit maintaining hash identity with BigInt beyond this scale
+ private final val hashCodeNotComputed = 0x5D50690F // Magic value (happens to be "BigDecimal" old MurmurHash3 value)
+ private final val deci2binary = 3.3219280948873626 // Ratio of log(10) to log(2)
private val minCached = -512
private val maxCached = 512
val defaultMathContext = MathContext.DECIMAL128
- /** Cache ony for defaultMathContext using BigDecimals in a small range. */
+ /** Cache only for defaultMathContext using BigDecimals in a small range. */
private lazy val cache = new Array[BigDecimal](maxCached - minCached + 1)
object RoundingMode extends Enumeration {
+ // Annoying boilerplate to ensure consistency with java.math.RoundingMode
+ import java.math.{RoundingMode => RM}
type RoundingMode = Value
- // These are supposed to be the same as java.math.RoundingMode.values,
- // though it seems unwise to rely on the correspondence.
- val UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY = Value
+ val UP = Value(RM.UP.ordinal)
+ val DOWN = Value(RM.DOWN.ordinal)
+ val CEILING = Value(RM.CEILING.ordinal)
+ val FLOOR = Value(RM.FLOOR.ordinal)
+ val HALF_UP = Value(RM.HALF_UP.ordinal)
+ val HALF_DOWN = Value(RM.HALF_DOWN.ordinal)
+ val HALF_EVEN = Value(RM.HALF_EVEN.ordinal)
+ val UNNECESSARY = Value(RM.UNNECESSARY.ordinal)
+ }
+
+ /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`, rounding if necessary. */
+ def decimal(d: Double, mc: MathContext): BigDecimal =
+ new BigDecimal(new BigDec(java.lang.Double.toString(d), mc))
+
+ /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`. */
+ def decimal(d: Double): BigDecimal = decimal(d, defaultMathContext)
+
+ /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`, rounding if necessary.
+ * Note that `BigDecimal.decimal(0.1f) != 0.1f` since equality agrees with the `Double` representation, and
+ * `0.1 != 0.1f`.
+ */
+ def decimal(f: Float, mc: MathContext): BigDecimal =
+ new BigDecimal(new BigDec(java.lang.Float.toString(f), mc))
+
+ /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`.
+ * Note that `BigDecimal.decimal(0.1f) != 0.1f` since equality agrees with the `Double` representation, and
+ * `0.1 != 0.1f`.
+ */
+ def decimal(f: Float): BigDecimal = decimal(f, defaultMathContext)
+
+ // This exists solely to avoid conversion from Int/Long to Float, screwing everything up.
+ /** Constructs a `BigDecimal` from a `Long`, rounding if necessary. This is identical to `BigDecimal(l, mc)`. */
+ def decimal(l: Long, mc: MathContext): BigDecimal = apply(l, mc)
+
+ // This exists solely to avoid conversion from Int/Long to Float, screwing everything up.
+ /** Constructs a `BigDecimal` from a `Long`. This is identical to `BigDecimal(l)`. */
+ def decimal(l: Long): BigDecimal = apply(l)
+
+ /** Constructs a `BigDecimal` using a `java.math.BigDecimal`, rounding if necessary. */
+ def decimal(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd.round(mc), mc)
+
+ /** Constructs a `BigDecimal` by expanding the binary fraction
+ * contained by `Double` value `d` into a decimal representation,
+ * rounding if necessary. When a `Float` is converted to a
+ * `Double`, the binary fraction is preserved, so this method
+ * also works for converted `Float`s.
+ */
+ def binary(d: Double, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(d, mc), mc)
+
+ /** Constructs a `BigDecimal` by expanding the binary fraction
+ * contained by `Double` value `d` into a decimal representation.
+ * Note: this also works correctly on converted `Float`s.
+ */
+ def binary(d: Double): BigDecimal = binary(d, defaultMathContext)
+
+ /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. The
+ * precision is the default for `BigDecimal` or enough to represent
+ * the `java.math.BigDecimal` exactly, whichever is greater.
+ */
+ def exact(repr: BigDec): BigDecimal = {
+ val mc =
+ if (repr.precision <= defaultMathContext.getPrecision) defaultMathContext
+ else new MathContext(repr.precision, java.math.RoundingMode.HALF_EVEN)
+ new BigDecimal(repr, mc)
}
+
+ /** Constructs a `BigDecimal` by fully expanding the binary fraction
+ * contained by `Double` value `d`, adjusting the precision as
+ * necessary. Note: this works correctly on converted `Float`s also.
+ */
+ def exact(d: Double): BigDecimal = exact(new BigDec(d))
+
+ /** Constructs a `BigDecimal` that exactly represents a `BigInt`.
+ */
+ def exact(bi: BigInt): BigDecimal = exact(new BigDec(bi.bigInteger))
+
+ /** Constructs a `BigDecimal` that exactly represents a `Long`. Note that
+ * all creation methods for `BigDecimal` that do not take a `MathContext`
+ * represent a `Long`; this is equivalent to `apply`, `valueOf`, etc..
+ */
+ def exact(l: Long): BigDecimal = apply(l)
+
+ /** Constructs a `BigDecimal` that exactly represents the number
+ * specified in a `String`.
+ */
+ def exact(s: String): BigDecimal = exact(new BigDec(s))
+
+ /** Constructs a 'BigDecimal` that exactly represents the number
+ * specified in base 10 in a character array.
+ */
+ def exact(cs: Array[Char]): BigDecimal = exact(new BigDec(cs))
+
/** Constructs a `BigDecimal` using the java BigDecimal static
- * valueOf constructor.
+ * valueOf constructor. Equivalent to `BigDecimal.decimal`.
*
* @param d the specified double value
* @return the constructed `BigDecimal`
*/
def valueOf(d: Double): BigDecimal = apply(BigDec valueOf d)
+
+ /** Constructs a `BigDecimal` using the java BigDecimal static
+ * valueOf constructor, specifying a `MathContext` that is
+ * used for computations but isn't used for rounding. Use
+ * `BigDecimal.decimal` to use `MathContext` for rounding,
+ * or `BigDecimal(java.math.BigDecimal.valueOf(d), mc)` for
+ * no rounding.
+ *
+ * @param d the specified double value
+ * @param mc the `MathContext` used for future computations
+ * @return the constructed `BigDecimal`
+ */
+ @deprecated("MathContext is not applied to Doubles in valueOf. Use BigDecimal.decimal to use rounding, or java.math.BigDecimal.valueOf to avoid it.","2.11")
def valueOf(d: Double, mc: MathContext): BigDecimal = apply(BigDec valueOf d, mc)
- def valueOf(x: Long): BigDecimal = apply(x.toDouble)
+
+ /** Constructs a `BigDecimal` using the java BigDecimal static
+ * valueOf constructor.
+ *
+ * @param x the specified `Long` value
+ * @return the constructed `BigDecimal`
+ */
+ def valueOf(x: Long): BigDecimal = apply(x)
+
+ /** Constructs a `BigDecimal` using the java BigDecimal static
+ * valueOf constructor. This is unlikely to do what you want;
+ * use `valueOf(f.toDouble)` or `decimal(f)` instead.
+ */
+ @deprecated("Float arguments to valueOf may not do what you wish. Use decimal or valueOf(f.toDouble).","2.11")
+ def valueOf(f: Float): BigDecimal = valueOf(f.toDouble)
+
+ /** Constructs a `BigDecimal` using the java BigDecimal static
+ * valueOf constructor. This is unlikely to do what you want;
+ * use `valueOf(f.toDouble)` or `decimal(f)` instead.
+ */
+ @deprecated("Float arguments to valueOf may not do what you wish. Use decimal or valueOf(f.toDouble).","2.11")
+ def valueOf(f: Float, mc: MathContext): BigDecimal = valueOf(f.toDouble, mc)
+
/** Constructs a `BigDecimal` whose value is equal to that of the
* specified `Integer` value.
*
@@ -53,6 +182,14 @@ object BigDecimal {
* @return the constructed `BigDecimal`
*/
def apply(i: Int): BigDecimal = apply(i, defaultMathContext)
+
+ /** Constructs a `BigDecimal` whose value is equal to that of the
+ * specified `Integer` value, rounding if necessary.
+ *
+ * @param i the specified integer value
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
def apply(i: Int, mc: MathContext): BigDecimal =
if (mc == defaultMathContext && minCached <= i && i <= maxCached) {
val offset = i - minCached
@@ -60,7 +197,7 @@ object BigDecimal {
if (n eq null) { n = new BigDecimal(BigDec.valueOf(i.toLong), mc); cache(offset) = n }
n
}
- else new BigDecimal(BigDec.valueOf(i.toLong), mc)
+ else apply(i.toLong, mc)
/** Constructs a `BigDecimal` whose value is equal to that of the
* specified long value.
@@ -72,6 +209,13 @@ object BigDecimal {
if (minCached <= l && l <= maxCached) apply(l.toInt)
else new BigDecimal(BigDec.valueOf(l), defaultMathContext)
+ /** Constructs a `BigDecimal` whose value is equal to that of the
+ * specified long value, but rounded if necessary.
+ *
+ * @param l the specified long value
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
def apply(l: Long, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(l, mc), mc)
@@ -85,35 +229,62 @@ object BigDecimal {
def apply(unscaledVal: Long, scale: Int): BigDecimal =
apply(BigInt(unscaledVal), scale)
+ /** Constructs a `BigDecimal` whose unscaled value is equal to that
+ * of the specified long value, but rounded if necessary.
+ *
+ * @param unscaledVal the value
+ * @param scale the scale
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
def apply(unscaledVal: Long, scale: Int, mc: MathContext): BigDecimal =
apply(BigInt(unscaledVal), scale, mc)
/** Constructs a `BigDecimal` whose value is equal to that of the
- * specified double value.
+ * specified double value. Equivalent to `BigDecimal.decimal`.
*
* @param d the specified `Double` value
* @return the constructed `BigDecimal`
*/
- def apply(d: Double): BigDecimal = apply(d, defaultMathContext)
+ def apply(d: Double): BigDecimal = decimal(d, defaultMathContext)
+
// note we don't use the static valueOf because it doesn't let us supply
// a MathContext, but we should be duplicating its logic, modulo caching.
- def apply(d: Double, mc: MathContext): BigDecimal =
- new BigDecimal(new BigDec(jl.Double.toString(d), mc), mc)
+ /** Constructs a `BigDecimal` whose value is equal to that of the
+ * specified double value, but rounded if necessary. Equivalent to
+ * `BigDecimal.decimal`.
+ *
+ * @param d the specified `Double` value
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
+ def apply(d: Double, mc: MathContext): BigDecimal = decimal(d, mc)
+ @deprecated("The default conversion from Float may not do what you want. Use BigDecimal.decimal for a String representation, or explicitly convert the Float with .toDouble.", "2.11")
def apply(x: Float): BigDecimal = apply(x.toDouble)
+
+ @deprecated("The default conversion from Float may not do what you want. Use BigDecimal.decimal for a String representation, or explicitly convert the Float with .toDouble.", "2.11")
def apply(x: Float, mc: MathContext): BigDecimal = apply(x.toDouble, mc)
/** Translates a character array representation of a `BigDecimal`
* into a `BigDecimal`.
*/
- def apply(x: Array[Char]): BigDecimal = apply(x, defaultMathContext)
+ def apply(x: Array[Char]): BigDecimal = exact(x)
+
+ /** Translates a character array representation of a `BigDecimal`
+ * into a `BigDecimal`, rounding if necessary.
+ */
def apply(x: Array[Char], mc: MathContext): BigDecimal =
- new BigDecimal(new BigDec(x.mkString, mc), mc)
+ new BigDecimal(new BigDec(x, mc), mc)
/** Translates the decimal String representation of a `BigDecimal`
* into a `BigDecimal`.
*/
- def apply(x: String): BigDecimal = apply(x, defaultMathContext)
+ def apply(x: String): BigDecimal = exact(x)
+
+ /** Translates the decimal String representation of a `BigDecimal`
+ * into a `BigDecimal`, rounding if necessary.
+ */
def apply(x: String, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(x, mc), mc)
@@ -123,7 +294,15 @@ object BigDecimal {
* @param x the specified `BigInt` value
* @return the constructed `BigDecimal`
*/
- def apply(x: BigInt): BigDecimal = apply(x, defaultMathContext)
+ def apply(x: BigInt): BigDecimal = exact(x)
+
+ /** Constructs a `BigDecimal` whose value is equal to that of the
+ * specified `BigInt` value, rounding if necessary.
+ *
+ * @param x the specified `BigInt` value
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
def apply(x: BigInt, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(x.bigInteger, mc), mc)
@@ -134,11 +313,24 @@ object BigDecimal {
* @param scale the scale
* @return the constructed `BigDecimal`
*/
- def apply(unscaledVal: BigInt, scale: Int): BigDecimal = apply(unscaledVal, scale, defaultMathContext)
+ def apply(unscaledVal: BigInt, scale: Int): BigDecimal =
+ exact(new BigDec(unscaledVal.bigInteger, scale))
+
+ /** Constructs a `BigDecimal` whose unscaled value is equal to that
+ * of the specified `BigInt` value.
+ *
+ * @param unscaledVal the specified `BigInt` value
+ * @param scale the scale
+ * @param mc the precision and rounding mode for creation of this value and future operations on it
+ * @return the constructed `BigDecimal`
+ */
def apply(unscaledVal: BigInt, scale: Int, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(unscaledVal.bigInteger, scale, mc), mc)
+ /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. */
def apply(bd: BigDec): BigDecimal = apply(bd, defaultMathContext)
+
+ @deprecated("This method appears to round a java.math.BigDecimal but actually doesn't. Use new BigDecimal(bd, mc) instead for no rounding, or BigDecimal.decimal(bd, mc) for rounding.", "2.11")
def apply(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd, mc)
/** Implicit conversion from `Int` to `BigDecimal`. */
@@ -148,43 +340,123 @@ object BigDecimal {
implicit def long2bigDecimal(l: Long): BigDecimal = apply(l)
/** Implicit conversion from `Double` to `BigDecimal`. */
- implicit def double2bigDecimal(d: Double): BigDecimal = valueOf(d, defaultMathContext)
+ implicit def double2bigDecimal(d: Double): BigDecimal = decimal(d)
/** Implicit conversion from `java.math.BigDecimal` to `scala.BigDecimal`. */
implicit def javaBigDecimal2bigDecimal(x: BigDec): BigDecimal = apply(x)
}
/**
+ * `BigDecimal` represents decimal floating-point numbers of arbitrary precision.
+ * By default, the precision approximately matches that of IEEE 128-bit floating
+ * point numbers (34 decimal digits, `HALF_EVEN` rounding mode). Within the range
+ * of IEEE binary128 numbers, `BigDecimal` will agree with `BigInt` for both
+ * equality and hash codes (and will agree with primitive types as well). Beyond
+ * that range--numbers with more than 4934 digits when written out in full--the
+ * `hashCode` of `BigInt` and `BigDecimal` is allowed to diverge due to difficulty
+ * in efficiently computing both the decimal representation in `BigDecimal` and the
+ * binary representation in `BigInt`.
+ *
+ * When creating a `BigDecimal` from a `Double` or `Float`, care must be taken as
+ * the binary fraction representation of `Double` and `Float` does not easily
+ * convert into a decimal representation. Three explicit schemes are available
+ * for conversion. `BigDecimal.decimal` will convert the floating-point number
+ * to a decimal text representation, and build a `BigDecimal` based on that.
+ * `BigDecimal.binary` will expand the binary fraction to the requested or default
+ * precision. `BigDecimal.exact` will expand the binary fraction to the
+ * full number of digits, thus producing the exact decimal value corrsponding to
+ * the binary fraction of that floating-point number. `BigDecimal` equality
+ * matches the decimal expansion of `Double`: `BigDecimal.decimal(0.1) == 0.1`.
+ * Note that since `0.1f != 0.1`, the same is not true for `Float`. Instead,
+ * `0.1f == BigDecimal.decimal((0.1f).toDouble)`.
+ *
+ * To test whether a `BigDecimal` number can be converted to a `Double` or
+ * `Float` and then back without loss of information by using one of these
+ * methods, test with `isDecimalDouble`, `isBinaryDouble`, or `isExactDouble`
+ * or the corresponding `Float` versions. Note that `BigInt`'s `isValidDouble`
+ * will agree with `isExactDouble`, not the `isDecimalDouble` used by default.
+ *
+ * `BigDecimal` uses the decimal representation of binary floating-point numbers
+ * to determine equality and hash codes. This yields different answers than
+ * conversion between `Long` and `Double` values, where the exact form is used.
+ * As always, since floating-point is a lossy representation, it is advisable to
+ * take care when assuming identity will be maintained across multiple conversions.
+ *
+ * `BigDecimal` maintains a `MathContext` that determines the rounding that
+ * is applied to certain calculations. In most cases, the value of the
+ * `BigDecimal` is also rounded to the precision specified by the `MathContext`.
+ * To create a `BigDecimal` with a different precision than its `MathContext`,
+ * use `new BigDecimal(new java.math.BigDecimal(...), mc)`. Rounding will
+ * be applied on those mathematical operations that can dramatically change the
+ * number of digits in a full representation, namely multiplication, division,
+ * and powers. The left-hand argument's `MathContext` always determines the
+ * degree of rounding, if any, and is the one propagated through arithmetic
+ * operations that do not apply rounding themselves.
+ *
* @author Stephane Micheloud
- * @version 1.0
+ * @author Rex Kerr
+ * @version 1.1
*/
-final class BigDecimal(
- val bigDecimal: BigDec,
- val mc: MathContext)
+final class BigDecimal(val bigDecimal: BigDec, val mc: MathContext)
extends ScalaNumber with ScalaNumericConversions with Serializable {
def this(bigDecimal: BigDec) = this(bigDecimal, BigDecimal.defaultMathContext)
import BigDecimal.RoundingMode._
-
- /** Cuts way down on the wrapper noise. */
- private implicit def bigdec2BigDecimal(x: BigDec): BigDecimal = new BigDecimal(x, mc)
-
+ import BigDecimal.{decimal, binary, exact}
+
+ if (bigDecimal eq null) throw new IllegalArgumentException("null value for BigDecimal")
+ if (mc eq null) throw new IllegalArgumentException("null MathContext for BigDecimal")
+
+ // There was an implicit to cut down on the wrapper noise for BigDec -> BigDecimal.
+ // However, this may mask introduction of surprising behavior (e.g. lack of rounding
+ // where one might expect it). Wrappers should be applied explicitly with an
+ // eye to correctness.
+
+ // Sane hash code computation (which is surprisingly hard).
+ // Note--not lazy val because we can't afford the extra space.
+ private final var computedHashCode: Int = BigDecimal.hashCodeNotComputed
+ private final def computeHashCode(): Unit = {
+ computedHashCode =
+ if (isWhole && (precision - scale) < BigDecimal.maximumHashScale) toBigInt.hashCode
+ else if (isValidDouble) doubleValue.##
+ else {
+ val temp = bigDecimal.stripTrailingZeros
+ scala.util.hashing.MurmurHash3.mixLast( temp.scaleByPowerOfTen(temp.scale).toBigInteger.hashCode, temp.scale )
+ }
+ }
+
/** Returns the hash code for this BigDecimal.
- * Note that this does not use the underlying java object's
- * hashCode because we compare BigDecimals with compareTo
+ * Note that this does not merely use the underlying java object's
+ * `hashCode` because we compare `BigDecimal`s with `compareTo`
* which deems 2 == 2.00, whereas in java these are unequal
- * with unequal hashCodes.
- */
- override def hashCode(): Int =
- if (isWhole()) unifiedPrimitiveHashcode()
- else doubleValue.##
+ * with unequal `hashCode`s. These hash codes agree with `BigInt`
+ * for whole numbers up ~4934 digits (the range of IEEE 128 bit floating
+ * point). Beyond this, hash codes will disagree; this prevents the
+ * explicit represention of the `BigInt` form for `BigDecimal` values
+ * with large exponents.
+ */
+ override def hashCode(): Int = {
+ if (computedHashCode == BigDecimal.hashCodeNotComputed) computeHashCode
+ computedHashCode
+ }
- /** Compares this BigDecimal with the specified value for equality.
+ /** Compares this BigDecimal with the specified value for equality. Where `Float` and `Double`
+ * disagree, `BigDecimal` will agree with the `Double` value
*/
override def equals (that: Any): Boolean = that match {
case that: BigDecimal => this equals that
- case that: BigInt => this.toBigIntExact exists (that equals _)
- case that: Double => isValidDouble && toDouble == that
- case that: Float => isValidFloat && toFloat == that
+ case that: BigInt =>
+ that.bitLength > (precision-scale-2)*BigDecimal.deci2binary &&
+ this.toBigIntExact.exists(that equals _)
+ case that: Double =>
+ !that.isInfinity && {
+ val d = toDouble
+ !d.isInfinity && d == that && equals(decimal(d))
+ }
+ case that: Float =>
+ !that.isInfinity && {
+ val f = toFloat
+ !f.isInfinity && f == that && equals(decimal(f.toDouble))
+ }
case _ => isValidLong && unifiedPrimitiveEquals(that)
}
override def isValidByte = noArithmeticException(toByteExact)
@@ -192,26 +464,71 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
override def isValidChar = isValidInt && toIntExact >= Char.MinValue && toIntExact <= Char.MaxValue
override def isValidInt = noArithmeticException(toIntExact)
def isValidLong = noArithmeticException(toLongExact)
- /** Returns `true` iff this can be represented exactly by [[scala.Float]]; otherwise returns `false`.
+ /** Tests whether the value is a valid Float. "Valid" has several distinct meanings, however. Use
+ * `isExactFloat`, `isBinaryFloat`, or `isDecimalFloat`, depending on the intended meaning.
+ * By default, `decimal` creation is used, so `isDecimalFloat` is probably what you want.
*/
+ @deprecated("What constitutes validity is unclear. Use `isExactFloat`, `isBinaryFloat`, or `isDecimalFloat` instead.", "2.11")
def isValidFloat = {
val f = toFloat
- !f.isInfinity && bigDecimal.compareTo(new java.math.BigDecimal(f.toDouble)) == 0
+ !f.isInfinity && bigDecimal.compareTo(new BigDec(f.toDouble)) == 0
}
- /** Returns `true` iff this can be represented exactly by [[scala.Double]]; otherwise returns `false`.
+ /** Tests whether the value is a valid Double. "Valid" has several distinct meanings, however. Use
+ * `isExactDouble`, `isBinaryDouble`, or `isDecimalDouble`, depending on the intended meaning.
+ * By default, `decimal` creation is used, so `isDecimalDouble` is probably what you want.
*/
+ @deprecated("Validity has two distinct meanings. Use `isExactBinaryDouble` or `equivalentToDouble` instead.", "2.11")
def isValidDouble = {
val d = toDouble
- !d.isInfinity && bigDecimal.compareTo(new java.math.BigDecimal(d)) == 0
+ !d.isInfinity && bigDecimal.compareTo(new BigDec(d)) == 0
+ }
+
+ /** Tests whether this `BigDecimal` holds the decimal representation of a `Double`. */
+ def isDecimalDouble = {
+ val d = toDouble
+ !d.isInfinity && equals(decimal(d))
+ }
+
+ /** Tests whether this `BigDecimal` holds the decimal representation of a `Float`. */
+ def isDecimalFloat = {
+ val f = toFloat
+ !f.isInfinity && equals(decimal(f))
+ }
+
+ /** Tests whether this `BigDecimal` holds, to within precision, the binary representation of a `Double`. */
+ def isBinaryDouble = {
+ val d = toDouble
+ !d.isInfinity && equals(binary(d,mc))
+ }
+
+ /** Tests whether this `BigDecimal` holds, to within precision, the binary representation of a `Float`. */
+ def isBinaryFloat = {
+ val f = toFloat
+ !f.isInfinity && equals(binary(f,mc))
+ }
+
+ /** Tests whether this `BigDecimal` holds the exact expansion of a `Double`'s binary fractional form into base 10. */
+ def isExactDouble = {
+ val d = toDouble
+ !d.isInfinity && equals(exact(d))
+ }
+
+ /** Tests whether this `BigDecimal` holds the exact expansion of a `Float`'s binary fractional form into base 10. */
+ def isExactFloat = {
+ val f = toFloat
+ !f.isInfinity && equals(exact(f.toDouble))
}
+
private def noArithmeticException(body: => Unit): Boolean = {
try { body ; true }
catch { case _: ArithmeticException => false }
}
- def isWhole() = (this remainder 1) == BigDecimal(0)
+ def isWhole() = scale <= 0 || bigDecimal.stripTrailingZeros.scale <= 0
+
def underlying = bigDecimal
+
/** Compares this BigDecimal with the specified BigDecimal for equality.
*/
@@ -239,60 +556,66 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
/** Addition of BigDecimals
*/
- def + (that: BigDecimal): BigDecimal = this.bigDecimal.add(that.bigDecimal)
+ def + (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal add that.bigDecimal, mc)
/** Subtraction of BigDecimals
*/
- def - (that: BigDecimal): BigDecimal = this.bigDecimal.subtract(that.bigDecimal)
+ def - (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal subtract that.bigDecimal, mc)
/** Multiplication of BigDecimals
*/
- def * (that: BigDecimal): BigDecimal = this.bigDecimal.multiply(that.bigDecimal, mc)
+ def * (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.multiply(that.bigDecimal, mc), mc)
/** Division of BigDecimals
*/
- def / (that: BigDecimal): BigDecimal = this.bigDecimal.divide(that.bigDecimal, mc)
+ def / (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal.divide(that.bigDecimal, mc), mc)
/** Division and Remainder - returns tuple containing the result of
- * divideToIntegralValue and the remainder.
+ * divideToIntegralValue and the remainder. The computation is exact: no rounding is applied.
*/
def /% (that: BigDecimal): (BigDecimal, BigDecimal) =
this.bigDecimal.divideAndRemainder(that.bigDecimal) match {
- case Array(q, r) => (q, r)
+ case Array(q, r) => (new BigDecimal(q, mc), new BigDecimal(r, mc))
}
/** Divide to Integral value.
*/
def quot (that: BigDecimal): BigDecimal =
- this.bigDecimal.divideToIntegralValue(that.bigDecimal)
+ new BigDecimal(this.bigDecimal divideToIntegralValue that.bigDecimal, mc)
- /** Returns the minimum of this and that
+ /** Returns the minimum of this and that, or this if the two are equal
*/
- def min (that: BigDecimal): BigDecimal = this.bigDecimal min that.bigDecimal
-
- /** Returns the maximum of this and that
+ def min (that: BigDecimal): BigDecimal = (this compare that) match {
+ case x if x <= 0 => this
+ case _ => that
+ }
+
+ /** Returns the maximum of this and that, or this if the two are equal
*/
- def max (that: BigDecimal): BigDecimal = this.bigDecimal max that.bigDecimal
-
+ def max (that: BigDecimal): BigDecimal = (this compare that) match {
+ case x if x >= 0 => this
+ case _ => that
+ }
+
/** Remainder after dividing this by that.
*/
- def remainder (that: BigDecimal): BigDecimal = this.bigDecimal.remainder(that.bigDecimal)
+ def remainder (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal remainder that.bigDecimal, mc)
/** Remainder after dividing this by that.
*/
- def % (that: BigDecimal): BigDecimal = this.remainder(that)
+ def % (that: BigDecimal): BigDecimal = this remainder that
/** Returns a BigDecimal whose value is this ** n.
*/
- def pow (n: Int): BigDecimal = this.bigDecimal.pow(n, mc)
+ def pow (n: Int): BigDecimal = new BigDecimal(this.bigDecimal.pow(n, mc), mc)
/** Returns a BigDecimal whose value is the negation of this BigDecimal
*/
- def unary_- : BigDecimal = this.bigDecimal.negate()
+ def unary_- : BigDecimal = new BigDecimal(this.bigDecimal.negate(), mc)
/** Returns the absolute value of this BigDecimal
*/
- def abs: BigDecimal = this.bigDecimal.abs
+ def abs: BigDecimal = if (signum < 0) unary_- else this
/** Returns the sign of this BigDecimal, i.e.
* -1 if it is less than 0,
@@ -305,9 +628,19 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
*/
def precision: Int = this.bigDecimal.precision()
- /** Returns a BigDecimal rounded according to the MathContext settings.
+ /** Returns a BigDecimal rounded according to the supplied MathContext settings, but
+ * preserving its own MathContext for future operations.
*/
- def round(mc: MathContext): BigDecimal = this.bigDecimal round mc
+ def round(mc: MathContext): BigDecimal = {
+ val r = this.bigDecimal round mc
+ if (r eq bigDecimal) this else new BigDecimal(r, this.mc)
+ }
+
+ /** Returns a `BigDecimal` rounded according to its own `MathContext` */
+ def rounded: BigDecimal = {
+ val r = bigDecimal round mc
+ if (r eq bigDecimal) this else new BigDecimal(r, mc)
+ }
/** Returns the scale of this `BigDecimal`.
*/
@@ -315,19 +648,22 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
/** Returns the size of an ulp, a unit in the last place, of this BigDecimal.
*/
- def ulp: BigDecimal = this.bigDecimal.ulp
+ def ulp: BigDecimal = new BigDecimal(this.bigDecimal.ulp, mc)
- /** Returns a new BigDecimal based on the supplied MathContext.
+ /** Returns a new BigDecimal based on the supplied MathContext, rounded as needed.
*/
- def apply(mc: MathContext): BigDecimal = BigDecimal(this.bigDecimal.toString, mc)
+ def apply(mc: MathContext): BigDecimal = new BigDecimal(this.bigDecimal round mc, mc)
/** Returns a `BigDecimal` whose scale is the specified value, and whose value is
* numerically equal to this BigDecimal's.
*/
- def setScale(scale: Int): BigDecimal = this.bigDecimal setScale scale
+ def setScale(scale: Int): BigDecimal =
+ if (this.scale == scale) this
+ else new BigDecimal(this.bigDecimal setScale scale, mc)
def setScale(scale: Int, mode: RoundingMode): BigDecimal =
- this.bigDecimal.setScale(scale, mode.id)
+ if (this.scale == scale) this
+ else new BigDecimal(this.bigDecimal.setScale(scale, mode.id), mc)
/** Converts this BigDecimal to a Byte.
* If the BigDecimal is too big to fit in a Byte, only the low-order 8 bits are returned.
@@ -442,8 +778,11 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
* can be done losslessly, returning Some(BigInt) or None.
*/
def toBigIntExact(): Option[BigInt] =
- try Some(new BigInt(this.bigDecimal.toBigIntegerExact()))
- catch { case _: ArithmeticException => None }
+ if (isWhole()) {
+ try Some(new BigInt(this.bigDecimal.toBigIntegerExact()))
+ catch { case _: ArithmeticException => None }
+ }
+ else None
/** Returns the decimal String representation of this BigDecimal.
*/
diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala
index 5e70bdc2f6..689fc0c3e1 100644
--- a/src/library/scala/math/BigInt.scala
+++ b/src/library/scala/math/BigInt.scala
@@ -119,7 +119,7 @@ final class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNum
*/
override def equals(that: Any): Boolean = that match {
case that: BigInt => this equals that
- case that: BigDecimal => that.toBigIntExact exists (this equals _)
+ case that: BigDecimal => that equals this
case that: Double => isValidDouble && toDouble == that
case that: Float => isValidFloat && toFloat == that
case x => isValidLong && unifiedPrimitiveEquals(x)
diff --git a/test/files/jvm/bigints.scala b/test/files/jvm/bigints.scala
index f0d05f8b71..06197cbb43 100644
--- a/test/files/jvm/bigints.scala
+++ b/test/files/jvm/bigints.scala
@@ -31,7 +31,6 @@ object Test_BigDecimal {
val xi: BigDecimal = 1
val xd: BigDecimal = 1.0
- val xf: BigDecimal = BigDecimal(1.0f)
val xs: BigDecimal = BigDecimal("1.0")
val xbi: BigDecimal = BigDecimal(scala.BigInt(1))
diff --git a/test/files/run/bigDecimalTest.check b/test/files/run/bigDecimalTest.check
index 6d11c23fcd..36db6aaafe 100644
--- a/test/files/run/bigDecimalTest.check
+++ b/test/files/run/bigDecimalTest.check
@@ -3,4 +3,4 @@
0
0
0
-14
+15
diff --git a/test/files/run/is-valid-num.scala b/test/files/run/is-valid-num.scala
index d314015dd4..65e8ceeca6 100644
--- a/test/files/run/is-valid-num.scala
+++ b/test/files/run/is-valid-num.scala
@@ -19,25 +19,27 @@ object Test {
assert(!x.isValidChar, x)
assert(!x.isValidShort, x)
assert(!x.isValidByte, x)
-// assert(y.isWhole, y)
+ assert(y.isWhole, y)
assert(!y.isValidShort, y)
assert(y.isValidChar, y)
assert(y.isValidInt, y)
- assert(y.isValidFloat, y)
- assert(y.isValidDouble, y)
+ assert(y.isDecimalFloat, y)
+ assert(y.isDecimalDouble, y)
assert(y.isValidLong, y)
assert(!y.isValidByte, y)
-// assert(!y1.isWhole)
+ assert(!y1.isWhole)
assert(!y1.isValidLong, y1)
- assert(!y1.isValidFloat, y1)
- assert(!y1.isValidDouble, y1)
+ assert(y1.isDecimalFloat, y1)
+ assert(y1.isDecimalDouble, y1)
+ assert(!y1.isExactFloat, y1)
+ assert(!y1.isExactDouble, y1)
assert(!y1.isValidInt, y1)
assert(!y1.isValidChar, y1)
assert(!y1.isValidShort, y1)
assert(!y1.isValidByte, y1)
assert(!y2.isValidLong, y2)
- assert(y2.isValidFloat, y2)
- assert(y2.isValidDouble, y2)
+ assert(y2.isExactFloat, y2)
+ assert(y2.isExactDouble, y2)
assert(!l1.isValidInt && (l1 - 1).isValidInt, l1)
assert(!l2.isValidInt && (l2 + 1).isValidInt, l2)
@@ -170,8 +172,8 @@ object Test {
if (!d.isInfinity) {
val bd = BigDecimal(new java.math.BigDecimal(d))
// assert(!bd.isWhole, bd)
- assert(bd.isValidDouble, bd)
- assert(bd.isValidFloat == isFloat, bd)
+ assert(bd.isExactDouble, bd)
+ assert(bd.isExactFloat == isFloat, bd)
assert(!bd.isValidLong, bd)
assert(!bd.isValidInt, bd)
assert(!bd.isValidChar, bd)
@@ -210,9 +212,9 @@ object Test {
val isFloat = !bi.toFloat.isInfinity && bd.compare(BigDecimal(new java.math.BigDecimal(bi.toFloat))) == 0
val isDouble = !bi.toDouble.isInfinity && bd.compare(BigDecimal(new java.math.BigDecimal(bi.toDouble))) == 0
-// assert(bd.isWhole, bd)
- assert(bd.isValidDouble == isDouble, bd)
- assert(bd.isValidFloat == isFloat, bd)
+ assert(bd.isWhole, bd)
+ assert(bd.isBinaryDouble == isDouble, bd)
+ assert(bd.isBinaryFloat == isFloat, bd)
assert(bd.isValidLong == isLong, bd)
assert(bd.isValidInt == isInt, bd)
assert(bd.isValidChar == isChar, bd)
diff --git a/test/files/run/numbereq.scala b/test/files/run/numbereq.scala
index d50db6d049..7ce4b23cf8 100644
--- a/test/files/run/numbereq.scala
+++ b/test/files/run/numbereq.scala
@@ -31,6 +31,24 @@ object Test {
).flatten
}
+ // Don't necessarily expect BigDecimal created from BigInt to agree with Double here.
+ def isIffy(x: Any, y: Any, canSwap: Boolean = true): Boolean = x match {
+ case bd: BigDecimal => y match {
+ case _: Float | _: Double => bd.toString.length > 15
+ case _ => false
+ }
+ case _ => canSwap && isIffy(y, x, false)
+ }
+
+ // Don't necessarily expect BigInt to agree with Float/Double beyond a Long
+ def isIffyB(x: Any, y: Any, canSwap: Boolean = true): Boolean = x match {
+ case bi: BigInt => y match {
+ case _: Float | _: Double => bi < Long.MinValue || bi > Long.MaxValue
+ case _ => false
+ }
+ case _ => canSwap && isIffyB(y, x, false)
+ }
+
def main(args: Array[String]): Unit = {
val ints = (0 to 15).toList map (Short.MinValue >> _)
val ints2 = ints map (x => -x)
@@ -46,7 +64,6 @@ object Test {
val sets = setneg1 ++ setneg2 ++ List(zero) ++ setpos1 ++ setpos2
for (set <- sets ; x <- set ; y <- set) {
- // println("'%s' == '%s' (%s == %s) (%s == %s)".format(x, y, x.hashCode, y.hashCode, x.##, y.##))
assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass))
assert(x.## == y.##, "%s != %s".format(x.getClass, y.getClass))
}
@@ -64,9 +81,11 @@ object Test {
val sets2 = setneg1 ++ setneg1b ++ setneg2 ++ setneg2b ++ List(zero) ++ setpos1 ++ setpos1b ++ setpos2 ++ setpos2b
for (set <- sets2 ; x <- set ; y <- set) {
-// println("'%s' == '%s' (%s == %s) (%s == %s)".format(x, y, x.hashCode, y.hashCode, x.##, y.##))
- assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass))
-// assert(x.## == y.##, "%s != %s".format(x.getClass, y.getClass)) Disable until Double.## is fixed (SI-5640)
+ if (!isIffy(x,y)) {
+ assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass))
+ // The following is blocked by SI-8150
+ // if (!isIffyB(x,y)) assert(x.## == y.##, "%x/%s != %x/%s from %s.## and %s.##".format(x.##, x.getClass, y.##, y.getClass, x, y))
+ }
}
}
}
diff --git a/test/junit/scala/math/BigDecimalTest.scala b/test/junit/scala/math/BigDecimalTest.scala
new file mode 100644
index 0000000000..d1ba96fcc8
--- /dev/null
+++ b/test/junit/scala/math/BigDecimalTest.scala
@@ -0,0 +1,225 @@
+package scala.math
+
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+import java.math.{BigDecimal => BD, MathContext => MC}
+
+/* Tests various maps by making sure they all agree on the same answers. */
+@RunWith(classOf[JUnit4])
+class BigDecimalTest {
+
+ // Motivated by SI-6173: BigDecimal#isWhole implementation is very heap intensive
+ @Test
+ def isWholeTest() {
+ val wholes = List(
+ BigDecimal(1),
+ BigDecimal(10L),
+ BigDecimal(14.000),
+ BigDecimal(new BD("19127981892347012385719827340123471923850195")),
+ BigDecimal("1e1000000000"),
+ BigDecimal(14.1928857191985e22),
+ BigDecimal(14.12519823759817, new MC(2))
+ )
+ val fracs = List(
+ BigDecimal(0.1),
+ BigDecimal(new BD("1.000000000000000000000000000000000001")),
+ BigDecimal(new BD("275712375971892375127591745810580123751.99999")),
+ BigDecimal("14.19238571927581e6"),
+ BigDecimal("912834718237510238591285")/2
+ )
+ assert(wholes.forall(_.isWhole) && fracs.forall(! _.isWhole))
+ }
+
+ // Motivated by SI-6699: BigDecimal.isValidDouble behaves unexpectedly
+ @Test
+ def isValidDoubleTest() {
+ val valids = List(
+ BigDecimal(1),
+ BigDecimal(19571.125),
+ BigDecimal.decimal(0.1),
+ BigDecimal(1e15)
+ )
+ val invalids = List(
+ BigDecimal(new BD("1.0000000000000000000000000000000000000000001")),
+ BigDecimal("10e1000000"),
+ BigDecimal("10e-1000000")
+ )
+ assert(
+ valids.forall(_.isDecimalDouble) &&
+ invalids.forall(! _.isDecimalDouble)
+ )
+ }
+
+ // Motivated by SI-6173: BigDecimal#isWhole implementation is very heap intensive
+ @Test
+ def doesNotExplodeTest() {
+ val troublemaker = BigDecimal("1e1000000000")
+ val reasonable = BigDecimal("1e1000")
+ val reasonableInt = reasonable.toBigInt
+ assert(
+ reasonable.hashCode == reasonableInt.hashCode &&
+ reasonable == reasonableInt &&
+ reasonableInt == reasonable &&
+ troublemaker.hashCode != reasonable.hashCode &&
+ !(troublemaker == reasonableInt) &&
+ !(reasonableInt == troublemaker)
+ )
+ }
+
+ // Motivated by SI-6456: scala.math.BigDecimal should not accept a null value
+ @Test
+ def refusesNullTest() {
+ def isIAE[A](a: => A) = try { a; false } catch { case iae: IllegalArgumentException => true }
+ def isNPE[A](a: => A) = try { a; false } catch { case npe: NullPointerException => true }
+ assert(
+ isIAE(new BigDecimal(null: BD, new MC(2))) &&
+ isIAE(new BigDecimal(new BD("5.7"), null: MC)) &&
+ isNPE(BigDecimal(null: BigInt)) &&
+ isNPE(BigDecimal(null: String)) &&
+ isNPE(BigDecimal(null: Array[Char]))
+ )
+ }
+
+ // Motivated by SI-6153: BigDecimal.hashCode() has high collision rate
+ @Test
+ def hashCodesAgreeTest() {
+ val bi: BigInt = 100000
+ val bd: BigDecimal = 100000
+ val l: Long = 100000
+ val d: Double = 100000
+ assert(
+ d.## == l.## &&
+ l.## == bd.## &&
+ bd.## == bi.## &&
+ (bd pow 4).hashCode == (bi pow 4).hashCode &&
+ BigDecimal("1e150000").hashCode != BigDecimal("1e150000").toBigInt.hashCode
+ )
+ }
+
+ // Motivated by noticing BigDecimal(0.1f) != BigDecimal(0.1)
+ @Test
+ def consistentTenthsTest() {
+ def tenths = List[Any](
+ BigDecimal("0.1"),
+ 0.1,
+ BigDecimal.decimal(0.1f),
+ BigDecimal.decimal(0.1),
+ BigDecimal(0.1),
+ BigDecimal(BigInt(1), 1),
+ BigDecimal(new BD("0.1")),
+ BigDecimal(1L, 1),
+ BigDecimal(1) / BigDecimal(10),
+ BigDecimal(10).pow(-1)
+ )
+ for (a <- tenths; b <- tenths) assert(a == b, s"$a != $b but both should be 0.1")
+ }
+
+ // Motivated by noticing BigDecimal(123456789, mc6) != BigDecimal(123456789L, mc6)
+ // where mc6 is a MathContext that rounds to six digits
+ @Test
+ def consistentRoundingTest() {
+ val mc6 = new MC(6)
+ val sameRounding = List(
+ List(
+ 123457000,
+ 123457000L,
+ 123457e3,
+ BigDecimal(123456789, mc6),
+ BigDecimal(123456789L, mc6),
+ BigDecimal(123456789d, mc6),
+ BigDecimal("123456789", mc6),
+ BigDecimal(Array('1','2','3','4','5','6','7','8','9'), mc6),
+ BigDecimal(BigInt(123456789), mc6),
+ BigDecimal(BigInt(1234567890), 1, mc6),
+ BigDecimal.decimal(123456789, mc6),
+ BigDecimal.decimal(123456789d, mc6),
+ BigDecimal.decimal(new BD("123456789"), mc6)
+ ),
+ List(
+ 123456789,
+ 123456789L,
+ 123456789d,
+ new BigDecimal(new BD("123456789"), mc6),
+ new BigDecimal(new BD("123456789")),
+ BigDecimal(123456789),
+ BigDecimal(123456789L),
+ BigDecimal(123456789d),
+ BigDecimal("123456789"),
+ BigDecimal(Array('1','2','3','4','5','6','7','8','9')),
+ BigDecimal(BigInt(123456789)),
+ BigDecimal(BigInt(1234567890), 1),
+ BigDecimal.decimal(123456789),
+ BigDecimal.decimal(123456789d),
+ BigDecimal.valueOf(123456789d, mc6)
+ )
+ )
+ sameRounding.map(_.zipWithIndex).foreach{ case xs =>
+ for ((a,i) <- xs; (b,j) <- xs) {
+ assert(a == b, s"$a != $b (#$i != #$j) but should be the same")
+ assert(a.## == b.##, s"Hash code mismatch in equal BigDecimals: #$i != #$j")
+ }
+ }
+ val List(xs, ys) = sameRounding.map(_.zipWithIndex)
+ for ((a,i) <- xs; (b,j) <- ys) assert(a != b, s"$a == $b (#$i == #$j) but should be different")
+ }
+
+ // This was unexpectedly truncated in 2.10
+ @Test
+ def noPrematureRoundingTest() {
+ val text = "9791375983750284059237954823745923845928547807345082378340572986452364"
+ val same = List[Any](
+ BigInt(text), BigDecimal(text), BigDecimal(new BD(text))
+ )
+ for (a <- same; b <- same) assert(a == b, s"$a != $b but should be the same")
+ }
+
+ // Tests attempts to make sane the representation of IEEE binary32 and binary64
+ // (i.e. Float and Double) with Scala's text-is-King BigDecimal policy
+ @Test
+ def churnRepresentationTest() {
+ val rn = new scala.util.Random(42)
+ for (i <- 1 to 1000) {
+ val d = rn.nextDouble
+ assert({
+ BigDecimal.decimal(d).isDecimalDouble &&
+ BigDecimal.binary(d).isBinaryDouble &&
+ BigDecimal.exact(d).isExactDouble
+ }, s"At least one wrong BigDecimal representation for $d")
+ }
+ for (i <- 1 to 1000) {
+ val f = rn.nextFloat
+ assert({
+ BigDecimal.decimal(f).isDecimalFloat &&
+ BigDecimal.binary(f).isBinaryFloat &&
+ BigDecimal.exact(f).isExactFloat
+ }, s"At least one wrong BigDecimal representation for $f")
+ }
+ for (i <- 1 to 1000) {
+ val ndig = 15+rn.nextInt(5)
+ val s = Array.fill(ndig)((rn.nextInt(10)+'0').toChar).mkString
+ val bi = BigInt(s)
+ val l = bi.toLong
+ val d = bi.toDouble
+ val bd = BigDecimal(bi)
+ val bd2 = BigDecimal.decimal(d)
+ assert(!bi.isValidLong || bi == l, s"Should be invalid or equal: $bi $l")
+ assert(!bi.isValidDouble || bi == d, s"Should be invalid or equal: $bi $d")
+ assert(bd == bi, s"Should be equal $bi $bd")
+ assert(bd.## == bi.##, s"Hash codes for $bi, $bd should be equal")
+ assert(bd == bd2 || bd2 != BigDecimal.exact(d) || !bi.isValidDouble,
+ s"$bd != $bd2 should only be when inexact or invalid")
+ assert(d == bd2 && bd2 == d, s"$d != $bd2 but they should equal")
+ }
+ val different = List(
+ BigDecimal.decimal(0.1),
+ BigDecimal.binary(0.1),
+ BigDecimal.binary(0.1, new MC(25)),
+ BigDecimal.exact(0.1),
+ BigDecimal.exact(0.1f),
+ BigDecimal.decimal((0.1f).toDouble)
+ )
+ for (a <- different; b <- different if (a ne b))
+ assert(a != b, "BigDecimal representations of Double mistakenly conflated")
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-05 20:17:40 +0000