Test two objects for inequality.

Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.

Division and Remainder - returns tuple containing the result of divideToIntegralValue and the remainder. The computation is exact: no rounding is applied.

Returns true if this is less than that

Returns true if this is less than or equal to that.

The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

Returns true if this is greater than that.

Returns true if this is greater than or equal to that.

Cast the receiver object to be of type T0.

Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.

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.

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.

Create a copy of the receiver object.

The default implementation of the clone method is platform dependent.

Compares this BigDecimal with the specified BigDecimal

Result of comparing this with operand that.

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.

Tests whether the argument (that) is a reference to the receiver object (this).

The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:

• It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
• For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
• null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

Compares this BigDecimal with the specified value for equality. Where Float and Double disagree, BigDecimal will agree with the Double value

Called by the garbage collector on the receiver object when there are no more references to the object.

The details of when and if the finalize method is invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

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.

Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

Returns the runtime class representation of the object.

Returns the hash code for this BigDecimal. Note that this does not merely 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. 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 representation of the BigInt form for BigDecimal values with large exponents.

Converts this BigDecimal to an Int. If the BigDecimal is too big to fit in an Int, 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.

Test whether the dynamic type of the receiver object is T0.

Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.

Returns true iff this has a zero fractional part, and is within the range of scala.Byte MinValue and MaxValue; otherwise returns false.

Returns true iff this has a zero fractional part, and is within the range of scala.Char MinValue and MaxValue; otherwise returns false.

Returns true iff this has a zero fractional part, and is within the range of scala.Int MinValue and MaxValue; otherwise returns false.

Returns true iff this has a zero fractional part, and is within the range of scala.Short MinValue and MaxValue; otherwise returns false.

Converts this BigDecimal to a Long. If the BigDecimal is too big to fit in a Long, 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.

Equivalent to !(this eq that).

Wakes up a single thread that is waiting on the receiver object's monitor.

Wakes up all threads that are waiting on the receiver object's monitor.

Converts this BigDecimal to a Short. If the BigDecimal is too big to fit in a Short, 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.

Returns the value of this as a scala.Byte. This may involve rounding or truncation.

Converts this BigDecimal to a scala.Byte, checking for lost information. If this BigDecimal has a nonzero fractional part, or is out of the possible range for a scala.Byte result, then a java.lang.ArithmeticException is thrown.

Returns the value of this as a scala.Char. This may involve rounding or truncation.

Returns the value of this as a scala.Double. This may involve rounding or truncation.

Returns the value of this as a scala.Float. This may involve rounding or truncation.

Returns the value of this as an scala.Int. This may involve rounding or truncation.

Converts this BigDecimal to a scala.Int, checking for lost information. If this BigDecimal has a nonzero fractional part, or is out of the possible range for an scala.Int result, then a java.lang.ArithmeticException is thrown.

Returns the value of this as a scala.Long. This may involve rounding or truncation.

Converts this BigDecimal to a scala.Long, checking for lost information. If this BigDecimal has a nonzero fractional part, or is out of the possible range for a scala.Long result, then a java.lang.ArithmeticException is thrown.

Returns the value of this as a scala.Short. This may involve rounding or truncation.

Converts this BigDecimal to a scala.Short, checking for lost information. If this BigDecimal has a nonzero fractional part, or is out of the possible range for a scala.Short result, then a java.lang.ArithmeticException is thrown.

Returns the decimal String representation of this BigDecimal.

Should only be called after all known non-primitive types have been excluded. This method won't dispatch anywhere else after checking against the primitives to avoid infinite recursion between equals and this on unknown "Number" variants.

Additionally, this should only be called if the numeric type is happy to be converted to Long, Float, and Double. If for instance a BigInt much larger than the Long range is sent here, it will claim equality with whatever Long is left in its lower 64 bits. Or a BigDecimal with more precision than Double can hold: same thing. There's no way given the interface available here to prevent this error.

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

Returns true if this is less than that

Returns true if this is less than or equal to that.

Returns true if this is greater than that.

Returns true if this is greater than or equal to that.

Result of comparing this with operand that.

Implement this method to determine how instances of A will be sorted.

Returns x where:

• x < 0 when this < that
• x == 0 when this == that
• x > 0 when this > that

Result of comparing this with operand that.

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.

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.