Scala 3
3.5.2
LearnInstallPlaygroundFind A LibraryCommunityBlog
LearnInstallPlaygroundFind A LibraryCommunityBlog
DocsAPI
Generated with
Copyright (c) 2002-2024, LAMP/EPFL
Copyright (c) 2002-2024, LAMP/EPFL
Scala 3/scala/scala.math

scala.math

package scala.math

The package object scala.math contains methods for performing basic numeric operations such as elementary exponential, logarithmic, root and trigonometric functions.

All methods forward to java.lang.Math unless otherwise noted.

Attributes

See also

Members list

Grouped members

Mathematical Constants

final val E: 2.718281828459045d

The Double value that is closer than any other to e, the base of the natural logarithms.

The Double value that is closer than any other to e, the base of the natural logarithms.

Attributes

Source
package.scala
final val Pi: 3.141592653589793d

The Double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

The Double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

Attributes

Source
package.scala

Minimum and Maximum

Find the min or max of two numbers. Note: scala.collection.IterableOnceOps has min and max methods which determine the min or max of a collection.

def max(x: Int, y: Int): Int

Attributes

Source
package.scala
def max(x: Long, y: Long): Long

Attributes

Source
package.scala
def max(x: Float, y: Float): Float

Attributes

Source
package.scala
def max(x: Double, y: Double): Double

Attributes

Source
package.scala
def min(x: Int, y: Int): Int

Attributes

Source
package.scala
def min(x: Long, y: Long): Long

Attributes

Source
package.scala
def min(x: Float, y: Float): Float

Attributes

Source
package.scala
def min(x: Double, y: Double): Double

Attributes

Source
package.scala

Rounding

def ceil(x: Double): Double

Attributes

Source
package.scala
def floor(x: Double): Double

Attributes

Source
package.scala
def rint(x: Double): Double

Returns the Double value that is closest in value to the argument and is equal to a mathematical integer.

Returns the Double value that is closest in value to the argument and is equal to a mathematical integer.

Value parameters

x

a Double value

Attributes

Returns

the closest floating-point value to a that is equal to a mathematical integer.

Source
package.scala
def round(x: Long): Long

There is no reason to round a Long, but this method prevents unintended conversion to Float followed by rounding to Int.

There is no reason to round a Long, but this method prevents unintended conversion to Float followed by rounding to Int.

Attributes

Note

Does not forward to java.lang.Math

Deprecated
true
Source
package.scala
def round(x: Float): Int

Returns the closest Int to the argument.

Returns the closest Int to the argument.

Value parameters

x

a floating-point value to be rounded to a Int.

Attributes

Returns

the value of the argument rounded to the nearest Int value.

Source
package.scala
def round(x: Double): Long

Returns the closest Long to the argument.

Returns the closest Long to the argument.

Value parameters

x

a floating-point value to be rounded to a Long.

Attributes

Returns

the value of the argument rounded to the nearestlong value.

Source
package.scala

Scaling

Scaling with rounding guarantees

def scalb(d: Double, scaleFactor: Int): Double

Attributes

Source
package.scala
def scalb(f: Float, scaleFactor: Int): Float

Attributes

Source
package.scala

Exponential and Logarithmic

def exp(x: Double): Double

Returns Euler's number e raised to the power of a Double value.

Returns Euler's number e raised to the power of a Double value.

Value parameters

x

the exponent to raise e to.

Attributes

Returns

the value ea, where e is the base of the natural logarithms.

Source
package.scala
def expm1(x: Double): Double

Returns exp(x) - 1.

Returns exp(x) - 1.

Attributes

Source
package.scala
def getExponent(f: Float): Int

Attributes

Source
package.scala
def getExponent(d: Double): Int

Attributes

Source
package.scala
def log(x: Double): Double

Returns the natural logarithm of a Double value.

Returns the natural logarithm of a Double value.

Value parameters

x

the number to take the natural logarithm of

Attributes

Returns

the value logₑ(x) where e is Eulers number

Source
package.scala
def log10(x: Double): Double

Returns the base 10 logarithm of the given Double value.

Returns the base 10 logarithm of the given Double value.

Attributes

Source
package.scala
def log1p(x: Double): Double

Returns the natural logarithm of the sum of the given Double value and 1.

Returns the natural logarithm of the sum of the given Double value and 1.

Attributes

Source
package.scala
def pow(x: Double, y: Double): Double

Returns the value of the first argument raised to the power of the second argument.

Returns the value of the first argument raised to the power of the second argument.

Value parameters

x

the base.

y

the exponent.

Attributes

Returns

the value xy.

Source
package.scala

Trigonometric

Arguments in radians

def acos(x: Double): Double

Attributes

Source
package.scala
def asin(x: Double): Double

Attributes

Source
package.scala
def atan(x: Double): Double

Attributes

Source
package.scala
def cos(x: Double): Double

Attributes

Source
package.scala
def sin(x: Double): Double

Attributes

Source
package.scala
def tan(x: Double): Double

Attributes

Source
package.scala

Angular Measurement Conversion

def toDegrees(x: Double): Double

Converts an angle measured in radians to an approximately equivalent angle measured in degrees.

Converts an angle measured in radians to an approximately equivalent angle measured in degrees.

Value parameters

x

angle, in radians

Attributes

Returns

the measurement of the angle x in degrees.

Source
package.scala
def toRadians(x: Double): Double

Converts an angle measured in degrees to an approximately equivalent angle measured in radians.

Converts an angle measured in degrees to an approximately equivalent angle measured in radians.

Value parameters

x

an angle, in degrees

Attributes

Returns

the measurement of the angle x in radians.

Source
package.scala

Hyperbolic

def cosh(x: Double): Double

Returns the hyperbolic cosine of the given Double value.

Returns the hyperbolic cosine of the given Double value.

Attributes

Source
package.scala
def sinh(x: Double): Double

Returns the hyperbolic sine of the given Double value.

Returns the hyperbolic sine of the given Double value.

Attributes

Source
package.scala
def tanh(x: Double): Double

Returns the hyperbolic tangent of the given Double value.

Returns the hyperbolic tangent of the given Double value.

Attributes

Source
package.scala

Absolute Values

Determine the magnitude of a value by discarding the sign. Results are >= 0.

def abs(x: Int): Int

Attributes

Source
package.scala
def abs(x: Long): Long

Attributes

Source
package.scala
def abs(x: Float): Float

Attributes

Source
package.scala
def abs(x: Double): Double

Attributes

Source
package.scala

Signs

For signum extract the sign of a value. Results are -1, 0 or 1. Note the signum methods are not pure forwarders to the Java versions. In particular, the return type of java.lang.Long.signum is Int, but here it is widened to Long so that each overloaded variant will return the same numeric type it is passed.

def copySign(magnitude: Double, sign: Double): Double

Attributes

Source
package.scala
def copySign(magnitude: Float, sign: Float): Float

Attributes

Source
package.scala
def signum(x: Int): Int

Attributes

Note

Forwards to java.lang.Integer

Source
package.scala
def signum(x: Long): Long

Attributes

Note

Forwards to java.lang.Long

Source
package.scala
def signum(x: Float): Float

Attributes

Source
package.scala
def signum(x: Double): Double

Attributes

Source
package.scala

Root Extraction

def cbrt(x: Double): Double

Returns the cube root of the given Double value.

Returns the cube root of the given Double value.

Value parameters

x

the number to take the cube root of

Attributes

Returns

the value ∛x

Source
package.scala
def sqrt(x: Double): Double

Returns the square root of a Double value.

Returns the square root of a Double value.

Value parameters

x

the number to take the square root of

Attributes

Returns

the value √x

Source
package.scala

Polar Coordinates

def atan2(y: Double, x: Double): Double

Converts rectangular coordinates (x, y) to polar (r, theta).

Converts rectangular coordinates (x, y) to polar (r, theta).

Value parameters

x

the ordinate coordinate

y

the abscissa coordinate

Attributes

Returns

the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.

Source
package.scala
def hypot(x: Double, y: Double): Double

Returns the square root of the sum of the squares of both given Double values without intermediate underflow or overflow.

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.

Attributes

Source
package.scala

Unit of Least Precision

def ulp(x: Double): Double

Returns the size of an ulp of the given Double value.

Returns the size of an ulp of the given Double value.

Attributes

Source
package.scala
def ulp(x: Float): Float

Returns the size of an ulp of the given Float value.

Returns the size of an ulp of the given Float value.

Attributes

Source
package.scala

Pseudo Random Number Generation

def random(): Double

Returns a Double value with a positive sign, greater than or equal to 0.0 and less than 1.0.

Returns a Double value with a positive sign, greater than or equal to 0.0 and less than 1.0.

Attributes

Source
package.scala

Exact Arithmetic

Integral addition, multiplication, stepping and conversion throwing ArithmeticException instead of underflowing or overflowing

def IEEEremainder(x: Double, y: Double): Double

Attributes

Source
package.scala
def addExact(x: Int, y: Int): Int

Attributes

Source
package.scala
def addExact(x: Long, y: Long): Long

Attributes

Source
package.scala
def decrementExact(x: Int): Int

Attributes

Source
package.scala
def decrementExact(x: Long): Long

Attributes

Source
package.scala
def incrementExact(x: Int): Int

Attributes

Source
package.scala
def incrementExact(x: Long): Long

Attributes

Source
package.scala
def multiplyExact(x: Int, y: Int): Int

Attributes

Source
package.scala
def multiplyExact(x: Long, y: Long): Long

Attributes

Source
package.scala
def negateExact(x: Int): Int

Attributes

Source
package.scala
def negateExact(x: Long): Long

Attributes

Source
package.scala
def subtractExact(x: Int, y: Int): Int

Attributes

Source
package.scala
def subtractExact(x: Long, y: Long): Long

Attributes

Source
package.scala
def toIntExact(x: Long): Int

Attributes

Source
package.scala

Modulus and Quotient

Calculate quotient values by rounding to negative infinity

def floorDiv(x: Int, y: Int): Int

Attributes

Source
package.scala
def floorDiv(x: Long, y: Long): Long

Attributes

Source
package.scala
def floorMod(x: Int, y: Int): Int

Attributes

Source
package.scala
def floorMod(x: Long, y: Long): Long

Attributes

Source
package.scala

Adjacent Floats

def nextAfter(start: Double, direction: Double): Double

Attributes

Source
package.scala
def nextAfter(start: Float, direction: Double): Float

Attributes

Source
package.scala
def nextDown(d: Double): Double

Attributes

Source
package.scala
def nextDown(f: Float): Float

Attributes

Source
package.scala
def nextUp(d: Double): Double

Attributes

Source
package.scala
def nextUp(f: Float): Float

Attributes

Source
package.scala

Type members

Classlikes

object BigDecimal

Attributes

Companion
class
Source
BigDecimal.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
BigDecimal.type
final class BigDecimal(val bigDecimal: BigDecimal, val mc: MathContext) extends ScalaNumber, ScalaNumericConversions, Serializable, Ordered[BigDecimal]

BigDecimal represents decimal floating-point numbers of arbitrary precision.

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 corresponding 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.

Attributes

Companion
object
Source
BigDecimal.scala
Supertypes
class ScalaNumber
class Number
trait Serializable
class Object
trait Matchable
class Any
Show all
object BigInt

Attributes

Companion
class
Source
BigInt.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
BigInt.type
final class BigInt extends ScalaNumber, ScalaNumericConversions, Serializable, Ordered[BigInt]

A type with efficient encoding of arbitrary integers.

A type with efficient encoding of arbitrary integers.

It wraps java.math.BigInteger, with optimization for small values that can be encoded in a Long.

Attributes

Companion
object
Source
BigInt.scala
Supertypes
trait Ordered[BigInt]
class ScalaNumber
class Number
trait Serializable
class Object
trait Matchable
class Any
Show all
trait Equiv[T] extends Serializable

A trait for representing equivalence relations.

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:

  1. reflexive: equiv(x, x) == true for any x of type T.

  2. symmetric: equiv(x, y) == equiv(y, x) for any x and y of type T.

  3. transitive: if equiv(x, y) == true and equiv(y, z) == true, then equiv(x, z) == true for any x, y, and z of type T.

Attributes

Companion
object
Source
Equiv.scala
Supertypes
trait Serializable
class Any
Known subtypes
object BigDecimal
object BigInt
object Boolean
object Byte
object Char
trait IeeeEquiv
object IeeeEquiv
trait StrictEquiv
object StrictEquiv
trait IeeeEquiv
object IeeeEquiv
trait StrictEquiv
object StrictEquiv
object Int
object Long
object Short
object String
object Symbol
object Unit
trait PartialOrdering[T]
trait Ordering[T]
object ValueOrdering
trait Numeric[T]
trait Fractional[T]
trait Integral[T]
object IntIsIntegral
object BigDecimal
object BigInt
object Boolean
trait ByteOrdering
object Byte
trait CachedReverse[T]
object Int
trait CharOrdering
object Char
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IntOrdering
trait LongOrdering
object Long
trait OptionOrdering[T]
object Short
object String
object Symbol
trait UnitOrdering
object Unit
Show all
object Equiv extends LowPriorityEquiv

Attributes

Companion
trait
Source
Equiv.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Equiv.type
trait Fractional[T] extends Numeric[T]

Attributes

Companion
object
Source
Fractional.scala
Supertypes
trait Numeric[T]
trait Ordering[T]
trait PartialOrdering[T]
trait Equiv[T]
trait Serializable
trait Comparator[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
Show all
object Fractional

Attributes

Companion
trait
Source
Fractional.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Fractional.type
trait Integral[T] extends Numeric[T]

Attributes

Companion
object
Source
Integral.scala
Supertypes
trait Numeric[T]
trait Ordering[T]
trait PartialOrdering[T]
trait Equiv[T]
trait Serializable
trait Comparator[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
object IntIsIntegral
Show all
object Integral

Attributes

Companion
trait
Source
Integral.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Integral.type
trait LowPriorityEquiv

Attributes

Source
Equiv.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Equiv
Self type
Equiv.type
trait LowPriorityOrderingImplicits

Attributes

Source
Ordering.scala
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Ordering
object Numeric

Attributes

Companion
trait
Source
Numeric.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Numeric.type
trait Numeric[T] extends Ordering[T]

Attributes

Companion
object
Source
Numeric.scala
Supertypes
trait Ordering[T]
trait PartialOrdering[T]
trait Equiv[T]
trait Serializable
trait Comparator[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
trait Fractional[T]
trait Integral[T]
object IntIsIntegral
Show all
trait Ordered[A] extends Comparable[A]

A trait for data that have a single, natural ordering.

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.

Attributes

See also
Companion
object
Source
Ordered.scala
Supertypes
trait Comparable[A]
class Object
trait Matchable
class Any
Known subtypes
class Deadline
class Duration
class Infinite
class Value
class Val
class BigDecimal
class BigInt
trait OrderedProxy[T]
class RichBoolean
trait ScalaNumberProxy[T]
trait FractionalProxy[T]
class RichDouble
class RichFloat
class RichInt
trait IntegralProxy[T]
class RichChar
class RichLong
class RichByte
class RichShort
Show all
object Ordered

Attributes

Companion
trait
Source
Ordered.scala
Supertypes
class Object
trait Matchable
class Any
Self type
Ordered.type
trait Ordering[T] extends Comparator[T], PartialOrdering[T], Serializable

Ordering is a trait whose instances each represent a strategy for sorting instances of a type.

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 built-in 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 the compare method, compare(a: T, b: T): Int, 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.

Attributes

See also
Companion
object
Source
Ordering.scala
Supertypes
trait PartialOrdering[T]
trait Equiv[T]
trait Serializable
trait Comparator[T]
class Object
trait Matchable
class Any
Show all
Known subtypes
object ValueOrdering
trait Numeric[T]
trait Fractional[T]
trait Integral[T]
object IntIsIntegral
object BigDecimal
object BigInt
object Boolean
trait ByteOrdering
object Byte
trait CachedReverse[T]
object Int
trait CharOrdering
object Char
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IntOrdering
trait LongOrdering
object Long
trait OptionOrdering[T]
object Short
object String
object Symbol
trait UnitOrdering
object Unit
Show all
Self type
object Ordering extends LowPriorityOrderingImplicits

This is the companion object for the scala.math.Ordering trait.

This is the companion object for the scala.math.Ordering trait.

It contains many implicit orderings as well as well as methods to construct new orderings.

Attributes

Companion
trait
Source
Ordering.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
Ordering.type
trait PartialOrdering[T] extends Equiv[T]

A trait for representing partial orderings.

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. - anti-symmetric: 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.

Attributes

Companion
object
Source
PartialOrdering.scala
Supertypes
trait Equiv[T]
trait Serializable
class Object
trait Matchable
class Any
Known subtypes
trait Ordering[T]
object ValueOrdering
trait Numeric[T]
trait Fractional[T]
trait Integral[T]
object IntIsIntegral
object BigDecimal
object BigInt
object Boolean
trait ByteOrdering
object Byte
trait CachedReverse[T]
object Int
trait CharOrdering
object Char
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IeeeOrdering
object IeeeOrdering
object TotalOrdering
trait IntOrdering
trait LongOrdering
object Long
trait OptionOrdering[T]
object Short
object String
object Symbol
trait UnitOrdering
object Unit
Show all
Self type
object PartialOrdering

Attributes

Companion
trait
Source
PartialOrdering.scala
Supertypes
trait Serializable
class Object
trait Matchable
class Any
Self type
trait PartiallyOrdered[+A]

A class for partially ordered data.

A class for partially ordered data.

Attributes

Source
PartiallyOrdered.scala
Supertypes
class Any
trait ScalaNumericAnyConversions

Conversions which present a consistent conversion interface across all the numeric types, suitable for use in value classes.

Conversions which present a consistent conversion interface across all the numeric types, suitable for use in value classes.

Attributes

Source
ScalaNumericConversions.scala
Supertypes
class Any
Known subtypes
class BigDecimal
class BigInt
trait ScalaNumberProxy[T]
trait FractionalProxy[T]
class RichDouble
class RichFloat
class RichInt
trait IntegralProxy[T]
class RichChar
class RichLong
class RichByte
class RichShort
Show all
trait ScalaNumericConversions extends ScalaNumber, ScalaNumericAnyConversions

A slightly more specific conversion trait for classes which extend ScalaNumber (which excludes value classes.)

A slightly more specific conversion trait for classes which extend ScalaNumber (which excludes value classes.)

Attributes

Source
ScalaNumericConversions.scala
Supertypes
class ScalaNumber
class Number
trait Serializable
class Object
trait Matchable
class Any
Show all
Known subtypes
class BigDecimal
class BigInt
Generated with
Copyright (c) 2002-2024, LAMP/EPFL
Copyright (c) 2002-2024, LAMP/EPFL