Пакет 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, чтобы получить доступ к другим неявным порядкам.

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 частично упорядоченное множество 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 отношение эквивалентности 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.