Пакет scala.math

BigDecimal представляет десятичные числа с плавающей точкой произвольной точности. По умолчанию, точность примерно соответствует точности чисел с плавающей точкой IEEE 128-битного формата (34 десятичных знака, HALF_EVEN режим округления). В пределах диапазона чисел IEEE binary128, BigDecimal будет совпадать с BigInt как для равенства, так и для хэш-кодов (и будет совпадать с примитивными типами тоже). За пределами этого диапазона — числа с более чем 4934 цифрами при полном представлении — hashCode BigInt и BigDecimal может отличаться из-за сложности эффективного вычисления десятичного представления в BigDecimal и двоичного представления в BigInt.

При создании BigDecimal из Double или Float, необходимо соблюдать осторожность, так как двоичное представление дробной части Double и Float не легко преобразуется в десятичное представление. Доступны три явных схемы преобразования. BigDecimal.decimal преобразует число с плавающей точкой в десятичное текстовое представление и строит BigDecimal на основе этого. BigDecimal.binary расширяет двоичную дробь до запрошенной или стандартной точности. BigDecimal.exact расширяет двоичную дробь до полного количества цифр, таким образом, получая точное десятичное значение, соответствующее двоичной дроби этого числа с плавающей точкой. BigDecimal равенство соответствует десятичному разложению Double: BigDecimal.decimal(0.1) == 0.1. Обратите внимание, что с 0.1f != 0.1, то же самое не относится к Float. Вместо этого 0.1f == BigDecimal.decimal((0.1f).toDouble).

Чтобы проверить, можно ли число BigDecimal преобразовать в Double или Float и обратно без потери информации с помощью одного из этих методов, проверьте isDecimalDouble, isBinaryDouble, или isExactDouble или соответствующие им Float версии. Обратите внимание, что BigInt's isValidDouble будет совпадать с isExactDouble, а не с isDecimalDouble используемым по умолчанию.

BigDecimal использует десятичное представление двоичных чисел с плавающей точкой для определения равенства и хэш-кодов. Это дает разные ответы, чем преобразование между Long и Double значениями, где используется точная форма. Как всегда, поскольку число с плавающей точкой является потерей информации, рекомендуется соблюдать осторожность при предположении о сохранении идентичности при множественных преобразованиях.

BigDecimal поддерживает MathContext, который определяет округление, применяемое к некоторым вычислениям. В большинстве случаев значение BigDecimal также округляется до точности, указанной в MathContext. Чтобы создать BigDecimal с точностью, отличной от MathContext, используйте new BigDecimal(new java.math.BigDecimal(...), mc). Округление будет применяться к тем математическим операциям, которые могут значительно изменить количество цифр в полном представлении, а именно умножению, делению и степеням. MathContext левого операнда всегда определяет степень округления (если необходимо) и является тем, который передается через арифметические операции, не применяющие округление сами.

Трейт для представления отношений эквивалентности. Важно различать тип, который может быть сравнен на равенство или эквивалентность, и представление эквивалентности на некотором типе. Этот трейт предназначен для представления последнего.

отношение эквивалентности — это бинарное отношение на типе. Это отношение показано как метод equiv трейта Equiv. Отношение должно быть:

рефлексивным: equiv(x, x) == true для любого x типа T.симметричным: equiv(x, y) == equiv(y, x) для любых x и y типа T.транзитивным: если equiv(x, y) == true и equiv(y, z) == true, то equiv(x, z) == true для любых x, y и z типа T.

Интерфейс для данных, имеющих единственный естественный порядок. См. scala.math.Ordering перед использованием этого интерфейса для получения дополнительной информации о том, следует ли использовать scala.math.Ordering вместо него.

Классы, реализующие этот интерфейс, могут быть отсортированы с помощью scala.util.Sorting и могут быть сравнины с помощью стандартных операторов сравнения (например, > и <).

Ordered следует использовать для данных с единственным естественным порядком (например, целые числа), в то время как Ordering позволяет реализовать несколько порядков. Экземпляр Ordering будет неявно создан при необходимости.

scala.math.Ordering — это альтернатива этому интерфейсу, которая позволяет определять несколько порядков для одного и того же типа.

scala.math.PartiallyOrdered — это альтернатива этому интерфейсу для частично упорядоченных данных.

Например, создайте простой класс, реализующий Ordered , а затем отсортируйте его с помощью 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

Важно, чтобы метод equals для экземпляра Ordered[A] был согласован с методом compare. Однако из-за ограничений, присущих семантике стирания типов, нет разумного способа предоставить реализацию по умолчанию для равенства экземпляров Ordered[A]. Поэтому, если вам нужно использовать равенство для экземпляра Ordered[A], вы должны предоставить его самостоятельно, либо при наследовании, либо при создании экземпляра.

Важно, чтобы метод hashCode для экземпляра Ordered[A] был согласован с методом compare. Однако предоставить разумную реализацию по умолчанию невозможно. Поэтому, если вам нужно вычислить хеш-код для экземпляра Ordered[A], вы должны предоставить его самостоятельно, либо при наследовании, либо при создании экземпляра.

Ordering — это интерфейс, экземпляры которого представляют стратегию сортировки экземпляров типа.

В компаньоне Ordering определено множество неявных объектов для работы с подтипами AnyVal (например, Int, Double), String и другими.

Для сортировки экземпляров по одному или нескольким переменным членам можно воспользоваться этими встроенными порядками с помощью Ordering.by и 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)))

Ordering[T] реализуется путем указания compare(a:T, b:T), которое определяет, как упорядочить два экземпляра a и b. Экземпляры Ordering[T] могут использоваться такими средствами, как scala.util.Sorting, для сортировки коллекций, таких как Array[T].

Например:

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)

Этот интерфейс и scala.math.Ordered оба предоставляют эту же функциональность, но по-разному. Тип T может получить единственный способ упорядочения, расширив Ordered. Используя Ordering, этот же тип может быть отсортирован многими другими способами. Ordered и Ordering оба предоставляют неявные преобразования, позволяющие использовать их взаимозаменяемо.

Вы можете импортировать scala.math.Ordering.Implicits, чтобы получить доступ к другим неявным порядкам.

Интерфейс для представления частичных порядков. Важно различать тип, имеющий частичный порядок, и представление частичного порядка для некоторого типа. Этот интерфейс предназначен для представления последнего.

Частичный порядок — это бинарное отношение на типе T, представленное методом lteq этого интерфейса. Это отношение должно быть:

рефлексивным: lteq(x, x) == true, для любого x типа T.антисимметричным: если lteq(x, y) == true и lteq(y, x) == true, то equiv(x, y) == true, для любых x и y типа T.транзитивным: если lteq(x, y) == true и lteq(y, z) == true, то lteq(x, z) == true, для любых x, y и z типа T.

Кроме того, частичный порядок индуцирует отношение эквивалентности на типе T: x и y типа T эквивалентны тогда и только тогда, когда lteq(x, y) && lteq(y, x) == true. Это отношение эквивалентности представлено методом equiv, унаследованным от интерфейса Equiv.