scala.math
package scala.math
randomisation
exact
abs
hyperbolic
modquo
ulp
minmax
signs
mathconst
The
Double
value that is closer than any other to e
, the base of
the natural logarithms. Source
 (source)
adjacentfloat
explog
Returns Euler's number
e
raised to the power of a Double
value.
 Value Params
 x

the exponent to raise
e
to.
 Returns

the value
ea
, wheree
is the base of the natural logarithms.  Source
 (source)
Returns the natural logarithm of a
Double
value.
 Value Params
 x

the number to take the natural logarithm of
 Returns

the value
logₑ(x)
wheree
is Eulers number  Source
 (source)
angleconversion
Converts an angle measured in radians to an approximately equivalent
angle measured in degrees.
 Value Params
 x

angle, in radians
 Returns

the measurement of the angle
x
in degrees.  Source
 (source)
rootextraction
Returns the cube root of the given
Double
value.
 Value Params
 x

the number to take the cube root of
 Returns

the value ∛x
 Source
 (source)
scaling
rounding
Returns the
Double
value that is closest in value to the
argument and is equal to a mathematical integer.
 Value Params
 x

a
Double
value
 Returns

the closest floatingpoint value to a that is equal to a mathematical integer.
 Source
 (source)
@deprecated("This is an integer type; there is no reason to round it. Perhaps you meant to call this with a floatingpoint value?", "2.11.0")
There is no reason to round a
Long
, but this method prevents unintended conversion to Float
followed by rounding to Int
.
 Note
 Does not forward to java.lang.Math
 Source
 (source)
Returns the closest
Int
to the argument.
 Value Params
 x

a floatingpoint value to be rounded to a
Int
.
 Returns

the value of the argument rounded to the nearest
Int
value.  Source
 (source)
polarcoords
Converts rectangular coordinates
(x, y)
to polar (r, theta)
.
 Value Params
 x

the ordinate coordinate
 y

the abscissa coordinate
 Returns

the theta component of the point
(r, theta)
in polar coordinates that corresponds to the point(x, y)
in Cartesian coordinates.  Source
 (source)
Returns the square root of the sum of the squares of both given
Double
values without intermediate underflow or overflow.The r component of the point
(r, theta)
in polar
coordinates that corresponds to the point (x, y)
in
Cartesian coordinates. Source
 (source)
Type members
Classlikes
final class BigDecimal(val bigDecimal: BigDecimal, val mc: MathContext) extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[BigDecimal]
BigDecimal
represents decimal floatingpoint numbers of arbitrary precision.
By default, the precision approximately matches that of IEEE 128bit 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 rangenumbers with more than 4934 digits when written out in fullthe
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 floatingpoint 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 corresponding to
the binary fraction of that floatingpoint 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 floatingpoint 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 floatingpoint 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 lefthand 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.
final class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[BigInt]
A trait for representing equivalence relations. It is important to
distinguish between a type that can be compared for equality or
equivalence and a representation of equivalence on some type. This
trait is for representing the latter.
An equivalence relation
is a binary relation on a type. This relation is exposed as
the
equiv
method of the Equiv
trait. The relation must be:
reflexive:
equiv(x, x) == true
for any x of typeT
. 
symmetric:
equiv(x, y) == equiv(y, x)
for anyx
andy
of typeT
. 
transitive: if
equiv(x, y) == true
andequiv(y, z) == true
, thenequiv(x, z) == true
for anyx
,y
, andz
of typeT
.
A trait for data that have a single, natural ordering. See
scala.math.Ordering before using this trait for
more information about whether to use scala.math.Ordering instead.
Classes that implement this trait can be sorted with
scala.util.Sorting and can be compared with standard comparison operators
(e.g. > and <).
Ordered should be used for data with a single, natural ordering (like
integers) while Ordering allows for multiple ordering implementations.
An Ordering instance will be implicitly created if necessary.
scala.math.Ordering is an alternative to this trait that allows multiple orderings to be
defined for the same type.
scala.math.PartiallyOrdered is an alternative to this trait for partially ordered data.
For example, create a simple class that implements
Ordered
and then sort it with scala.util.Sorting:case class OrderedClass(n:Int) extends Ordered[OrderedClass] {
def compare(that: OrderedClass) = this.n  that.n
}
val x = Array(OrderedClass(1), OrderedClass(5), OrderedClass(3))
scala.util.Sorting.quickSort(x)
x
It is important that the
equals
method for an instance of Ordered[A]
be consistent with the
compare method. However, due to limitations inherent in the type erasure semantics, there is no
reasonable way to provide a default implementation of equality for instances of Ordered[A]
.
Therefore, if you need to be able to use equality on an instance of Ordered[A]
you must
provide it yourself either when inheriting or instantiating.It is important that the
hashCode
method for an instance of Ordered[A]
be consistent with
the compare
method. However, it is not possible to provide a sensible default implementation.
Therefore, if you need to be able compute the hash of an instance of Ordered[A]
you must
provide it yourself either when inheriting or instantiating.
@implicitNotFound(msg = "No implicit Ordering defined for ${T}.")
Ordering is a trait whose instances each represent a strategy for sorting
instances of a type.
Ordering's companion object defines many implicit objects to deal with
subtypes of AnyVal (e.g. Int, Double), String, and others.
To sort instances by one or more member variables, you can take advantage
of these builtin orderings using Ordering.by and Ordering.on:
import scala.util.Sorting
val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3))
// sort by 2nd element
Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2))
// sort by the 3rd element, then 1st
Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1)))
An Ordering[T] is implemented by specifying compare(a:T, b:T), which
decides how to order two instances a and b. Instances of Ordering[T] can be
used by things like scala.util.Sorting to sort collections like Array[T].
For example:
import scala.util.Sorting
case class Person(name:String, age:Int)
val people = Array(Person("bob", 30), Person("ann", 32), Person("carl", 19))
// sort by age
object AgeOrdering extends Ordering[Person] {
def compare(a:Person, b:Person) = a.age compare b.age
}
Sorting.quickSort(people)(AgeOrdering)
This trait and scala.math.Ordered both provide this same functionality, but
in different ways. A type T can be given a single way to order itself by
extending Ordered. Using Ordering, this same type may be sorted in many
other ways. Ordered and Ordering both provide implicits allowing them to be
used interchangeably.
You can import scala.math.Ordering.Implicits to gain access to other
implicit orderings.
 See also
 scala.math.Ordered, scala.util.Sorting
 Companion
 object
 Source
 (source)
A trait for representing partial orderings. It is important to
distinguish between a type that has a partial order and a representation
of partial ordering on some type. This trait is for representing the
latter.
A partial ordering is a
binary relation on a type
T
, exposed as the lteq
method of this trait.
This relation must be: reflexive:
lteq(x, x) == true
, for any x
of type T
.
 antisymmetric: if lteq(x, y) == true
and
lteq(y, x) == true
then equiv(x, y) == true
, for any x
and y
of type T
.
 transitive: if lteq(x, y) == true
and
lteq(y, z) == true
then lteq(x, z) == true
,
for any x
, y
, and z
of type T
.Additionally, a partial ordering induces an
equivalence relation
on a type
T
: x
and y
of type T
are equivalent if and only if
lteq(x, y) && lteq(y, x) == true
. This equivalence relation is
exposed as the equiv
method, inherited from the
Equiv trait.
Conversions which present a consistent conversion interface
across all the numeric types, suitable for use in value classes.
 Source
 (source)
A slightly more specific conversion trait for classes which
extend ScalaNumber (which excludes value classes.)
 Source
 (source)