Scala example source code file (BigDecimal.scala)
The Scala BigDecimal.scala source code/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2007-2011, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.math
import java.{ lang => jl }
import java.math.{ MathContext, BigDecimal => BigDec }
import scala.collection.immutable.NumericRange
import annotation.migration
/**
* @author Stephane Micheloud
* @version 1.0
* @since 2.7
*/
object BigDecimal {
private val minCached = -512
private val maxCached = 512
val defaultMathContext = MathContext.DECIMAL128
@deprecated("Use Long.MinValue", "2.9.0")
val MinLong = new BigDecimal(BigDec valueOf Long.MinValue, defaultMathContext)
@deprecated("Use Long.MaxValue", "2.9.0")
val MaxLong = new BigDecimal(BigDec valueOf Long.MaxValue, defaultMathContext)
/** Cache ony for defaultMathContext using BigDecimals in a small range. */
private lazy val cache = new Array[BigDecimal](maxCached - minCached + 1)
object RoundingMode extends Enumeration(java.math.RoundingMode.values map (_.toString) : _*) with Serializable {
type RoundingMode = Value
val UP, DOWN, CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UNNECESSARY = Value
}
/** Constructs a `BigDecimal` using the java BigDecimal static
* valueOf constructor.
*
* @param d the specified double value
* @return the constructed `BigDecimal`
*/
def valueOf(d: Double): BigDecimal = apply(BigDec valueOf d)
def valueOf(d: Double, mc: MathContext): BigDecimal = apply(BigDec valueOf d, mc)
/** Constructs a `BigDecimal` whose value is equal to that of the
* specified `Integer` value.
*
* @param i the specified integer value
* @return the constructed `BigDecimal`
*/
def apply(i: Int): BigDecimal = apply(i, defaultMathContext)
def apply(i: Int, mc: MathContext): BigDecimal =
if (mc == defaultMathContext && minCached <= i && i <= maxCached) {
val offset = i - minCached
var n = cache(offset)
if (n eq null) { n = new BigDecimal(BigDec.valueOf(i), mc); cache(offset) = n }
n
}
else new BigDecimal(BigDec.valueOf(i), mc)
/** Constructs a `BigDecimal` whose value is equal to that of the
* specified long value.
*
* @param l the specified long value
* @return the constructed `BigDecimal`
*/
def apply(l: Long): BigDecimal =
if (minCached <= l && l <= maxCached) apply(l.toInt)
else new BigDecimal(BigDec.valueOf(l), defaultMathContext)
def apply(l: Long, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(l, mc), mc)
/** Constructs a `BigDecimal` whose unscaled value is equal to that
* of the specified long value.
*
* @param unscaledVal the value
* @param scale the scale
* @return the constructed `BigDecimal`
*/
def apply(unscaledVal: Long, scale: Int): BigDecimal =
apply(BigInt(unscaledVal), scale)
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.
*
* @param d the specified `Double` value
* @return the constructed `BigDecimal`
*/
def apply(d: Double): BigDecimal = apply(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)
/** 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], mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(x.mkString, 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, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(x, mc), mc)
/** Constructs a `BigDecimal` whose value is equal to that of the
* specified `BigInt` value.
*
* @param x the specified `BigInt` value
* @return the constructed `BigDecimal`
*/
def apply(x: BigInt): BigDecimal = apply(x, defaultMathContext)
def apply(x: BigInt, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(x.bigInteger, mc), mc)
/** 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
* @return the constructed `BigDecimal`
*/
def apply(unscaledVal: BigInt, scale: Int): BigDecimal = apply(unscaledVal, scale, defaultMathContext)
def apply(unscaledVal: BigInt, scale: Int, mc: MathContext): BigDecimal =
new BigDecimal(new BigDec(unscaledVal.bigInteger, scale, mc), mc)
def apply(bd: BigDec): BigDecimal = apply(bd, defaultMathContext)
def apply(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd, mc)
/** Implicit conversion from `Int` to `BigDecimal`. */
implicit def int2bigDecimal(i: Int): BigDecimal = apply(i)
/** Implicit conversion from `Long` to `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 conversion from `java.math.BigDecimal` to `scala.BigDecimal`. */
implicit def javaBigDecimal2bigDecimal(x: BigDec): BigDecimal = apply(x)
}
/**
* @author Stephane Micheloud
* @version 1.0
*/
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)
/** 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
* which deems 2 == 2.00, whereas in java these are unequal
* with unequal hashCodes.
*/
override def hashCode(): Int =
if (isWhole) unifiedPrimitiveHashcode
else doubleValue.##
/** Compares this BigDecimal with the specified value for equality.
*/
override def equals (that: Any): Boolean = that match {
case that: BigDecimal => this equals that
case that: BigInt => this.toBigIntExact exists (that equals _)
case _: Float | _: Double => unifiedPrimitiveEquals(that)
case _ => fitsInLong && unifiedPrimitiveEquals(that)
}
private def fitsInLong = isWhole && this <= Long.MaxValue && this >= Long.MinValue
protected[math] def isWhole = (this remainder 1) == BigDecimal(0)
def underlying = bigDecimal
/** Compares this BigDecimal with the specified BigDecimal for equality.
*/
def equals (that: BigDecimal): Boolean = compare(that) == 0
/** Compares this BigDecimal with the specified BigDecimal
*/
def compare (that: BigDecimal): Int = this.bigDecimal compareTo that.bigDecimal
/** Less-than-or-equals comparison of BigDecimals
*/
def <= (that: BigDecimal): Boolean = compare(that) <= 0
/** Greater-than-or-equals comparison of BigDecimals
*/
def >= (that: BigDecimal): Boolean = compare(that) >= 0
/** Less-than of BigDecimals
*/
def < (that: BigDecimal): Boolean = compare(that) < 0
/** Greater-than comparison of BigDecimals
*/
def > (that: BigDecimal): Boolean = compare(that) > 0
/** Addition of BigDecimals
*/
def + (that: BigDecimal): BigDecimal = this.bigDecimal.add(that.bigDecimal, mc)
/** Subtraction of BigDecimals
*/
def - (that: BigDecimal): BigDecimal = this.bigDecimal.subtract(that.bigDecimal, mc)
/** Multiplication of BigDecimals
*/
def * (that: BigDecimal): BigDecimal = this.bigDecimal.multiply(that.bigDecimal, mc)
/** Division of BigDecimals
*/
def / (that: BigDecimal): BigDecimal = this.bigDecimal.divide(that.bigDecimal, mc)
/** Division and Remainder - returns tuple containing the result of
* divideToIntegralValue and the remainder.
*/
def /% (that: BigDecimal): (BigDecimal, BigDecimal) =
this.bigDecimal.divideAndRemainder(that.bigDecimal, mc) match {
case Array(q, r) => (q, r)
}
/** Divide to Integral value.
*/
def quot (that: BigDecimal): BigDecimal =
this.bigDecimal.divideToIntegralValue(that.bigDecimal, mc)
/** Returns the minimum of this and that
*/
def min (that: BigDecimal): BigDecimal = this.bigDecimal min that.bigDecimal
/** Returns the maximum of this and that
*/
def max (that: BigDecimal): BigDecimal = this.bigDecimal max that.bigDecimal
/** Remainder after dividing this by that.
*/
def remainder (that: BigDecimal): BigDecimal = this.bigDecimal.remainder(that.bigDecimal, mc)
/** Remainder after dividing this by 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)
/** Returns a BigDecimal whose value is the negation of this BigDecimal
*/
def unary_- : BigDecimal = this.bigDecimal.negate(mc)
/** Returns the absolute value of this BigDecimal
*/
def abs: BigDecimal = this.bigDecimal abs mc
/** Returns the sign of this BigDecimal, i.e.
* -1 if it is less than 0,
* +1 if it is greater than 0
* 0 if it is equal to 0
*/
def signum: Int = this.bigDecimal.signum()
/** Returns the precision of this `BigDecimal`.
*/
def precision: Int = this.bigDecimal.precision()
/** Returns a BigDecimal rounded according to the MathContext settings.
*/
def round(mc: MathContext): BigDecimal = this.bigDecimal round mc
/** Returns the scale of this `BigDecimal`.
*/
def scale: Int = this.bigDecimal.scale()
/** Returns the size of an ulp, a unit in the last place, of this BigDecimal.
*/
def ulp: BigDecimal = this.bigDecimal.ulp
/** Returns a new BigDecimal based on the supplied MathContext.
*/
def apply(mc: MathContext): BigDecimal = BigDecimal(this.bigDecimal.toString, 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, mode: RoundingMode): BigDecimal =
this.bigDecimal.setScale(scale, mode.id)
/** 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.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value as well as return a result with the opposite sign.
*/
override def byteValue = intValue.toByte
/** Converts this BigDecimal to a Short.
* If the BigDecimal is too big to fit in a Byte, only the low-order 16 bits are returned.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value as well as return a result with the opposite sign.
*/
override def shortValue = intValue.toShort
/** Converts this BigDecimal to a Char.
* If the BigDecimal is too big to fit in a char, only the low-order 16 bits are returned.
* Note that this conversion can lose information about the overall magnitude of the
* BigDecimal value and that it always returns a positive result.
*/
def charValue = intValue.toChar
/** Converts this BigDecimal to an Int.
* If the BigDecimal is too big to fit in a char, only the low-order 32 bits
* are returned. Note that this conversion can lose information about the
* overall magnitude of the BigDecimal value as well as return a result with
* the opposite sign.
*/
def intValue = this.bigDecimal.intValue
/** Converts this BigDecimal to a Long.
* If the BigDecimal is too big to fit in a char, only the low-order 64 bits
* are returned. Note that this conversion can lose information about the
* overall magnitude of the BigDecimal value as well as return a result with
* the opposite sign.
*/
def longValue = this.bigDecimal.longValue
/** Converts this BigDecimal to a Float.
* if this BigDecimal has too great a magnitude to represent as a float,
* it will be converted to `Float.NEGATIVE_INFINITY` or
* `Float.POSITIVE_INFINITY` as appropriate.
*/
def floatValue = this.bigDecimal.floatValue
/** Converts this BigDecimal to a Double.
* if this BigDecimal has too great a magnitude to represent as a double,
* it will be converted to `Double.NEGATIVE_INFINITY` or
* `Double.POSITIVE_INFINITY` as appropriate.
*/
def doubleValue = this.bigDecimal.doubleValue
/** This BigDecimal as an exact value.
*/
def toByteExact = bigDecimal.byteValueExact
def toShortExact = bigDecimal.shortValueExact
def toIntExact = bigDecimal.intValueExact
def toLongExact = bigDecimal.longValueExact
/** Creates a partially constructed NumericRange[BigDecimal] in range
* `[start;end)`, where start is the target BigDecimal. The step
* must be supplied via the "by" method of the returned object in order
* to receive the fully constructed range. For example:
* {{{
* val partial = BigDecimal(1.0) to 2.0 // not usable yet
* val range = partial by 0.01 // now a NumericRange
* val range2 = BigDecimal(0) to 1.0 by 0.01 // all at once of course is fine too
* }}}
*
* @param end the end value of the range (exclusive)
* @return the partially constructed NumericRange
*/
def until(end: BigDecimal): Range.Partial[BigDecimal, NumericRange.Exclusive[BigDecimal]] =
new Range.Partial(until(end, _))
/** Same as the one-argument `until`, but creates the range immediately. */
def until(end: BigDecimal, step: BigDecimal) = Range.BigDecimal(this, end, step)
/** Like `until`, but inclusive of the end value. */
def to(end: BigDecimal): Range.Partial[BigDecimal, NumericRange.Inclusive[BigDecimal]] =
new Range.Partial(to(end, _))
/** Like `until`, but inclusive of the end value. */
def to(end: BigDecimal, step: BigDecimal) = Range.BigDecimal.inclusive(this, end, step)
/** Converts this `BigDecimal` to a scala.BigInt.
*/
def toBigInt(): BigInt = new BigInt(this.bigDecimal.toBigInteger())
/** Converts this `BigDecimal` to a scala.BigInt if it
* can be done losslessly, returning Some(BigInt) or None.
*/
def toBigIntExact(): Option[BigInt] =
try Some(new BigInt(this.bigDecimal.toBigIntegerExact()))
catch { case _: ArithmeticException => None }
/** Returns the decimal String representation of this BigDecimal.
*/
override def toString(): String = this.bigDecimal.toString()
}
Other Scala examples (source code examples)Here is a short list of links related to this Scala BigDecimal.scala source code file: |
The search page
Other Scala source code examples at this package level
Click here to learn more about this project
