Пакет scala.math.scala.math

пакет scala.math

Объект пакета scala.math содержит методы для выполнения основных числовых операций, таких как элементарные экспоненциальные, логарифмические, корневые и тригонометрические функции.

Все методы передаются в java.lang.Math, если не указано иное.

Математические константы

Источник@inline

final val E: 2.718281828459045d

Значение Double, которое ближе всего к e, основанию натуральных логарифмов.

Источник@inline

final val Pi: 3.141592653589793d

Значение Double, которое ближе всего к pi, отношению длины окружности к её диаметру.

Минимальное и максимальное значение

Нахождение минимального или максимального значения из двух чисел. Примечание: в scala.collection.IterableOnceOps есть методы min и max, которые определяют минимальное или максимальное значение коллекции.

Источник

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

Источник

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

Источник

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

Источник

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

Источник

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

Источник

def min(x: Long, y: Long): Long

Источник

def min(x: Float, y: Float): Float

Источник

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

Округление

Источник

def ceil(x: Double): Double

Источник

def floor(x: Double): Double

Источник

def rint(x: Double): Double

Возвращает значение Double, наиболее близкое по значению к аргументу и равное математическому целому числу.

Источник@deprecated("Это целочисленный тип; нет причины его округлять. Возможно, вы имели в виду вызов этого метода с числом с плавающей точкой?", "2.11.0")

def round(x: Long): Long

Нет причины округлять Long, но этот метод предотвращает непреднамеренное преобразование в Float, за которым следует округление до Int.

Источник

def round(x: Float): Int

Возвращает ближайшее Int к аргументу.

Источник

def round(x: Double): Long

Возвращает ближайшее Long к аргументу.

Масштабирование

Масштабирование с гарантией округления

Источник

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

Источник

def scalb(f: Float, scaleFactor: Int): Float

Экспоненциальные и логарифмические

Источник

def exp(x: Double): Double

Возвращает число Эйлера e, возведённое в степень значения с плавающей точкой.

Источник

def expm1(x: Double): Double

Возвращает значение exp(x) - 1.

Источник

def getExponent(f: Float): Int

Источник

def getExponent(d: Double): Int

Источник

def log(x: Double): Double

Возвращает натуральный логарифм значения с плавающей точкой.

Источник

def log10(x: Double): Double

Возвращает логарифм по основанию 10 данного значения с плавающей точкой.

Источник

def log1p(x: Double): Double

Возвращает натуральный логарифм суммы данного значения с плавающей точкой и 1.

Источник

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

Возвращает значение первого аргумента, возведённого в степень второго аргумента.

Тригонометрические

Аргументы в радианах

Исходный код

def acos(x: Double): Double

Исходный код

def asin(x: Double): Double

Исходный код

def atan(x: Double): Double

Исходный код

def cos(x: Double): Double

Исходный код

def sin(x: Double): Double

Исходный код

def tan(x: Double): Double

Преобразование угловых измерений

Исходный код

def toDegrees(x: Double): Double

Преобразует угол, измеренный в радианах, в приблизительно эквивалентный угол, измеренный в градусах.

Исходный код

def toRadians(x: Double): Double

Преобразует угол, измеренный в градусах, в приблизительно эквивалентный угол, измеренный в радианах.

Гиперболические

Исходный код

def cosh(x: Double): Double

Возвращает гиперболический косинус заданного Double значения.

Исходный код

def sinh(x: Double): Double

Возвращает гиперболический синус заданного Double значения.

Исходный код

def tanh(x: Double): Double

Возвращает гиперболическую тангенс заданного Double значения.

Модули

Определяет величину значения, отбрасывая знак. Результаты >= 0.

Исходный код

def abs(x: Int): Int

Исходный код

def abs(x: Long): Long

Исходный код

def abs(x: Float): Float

Исходный код

def abs(x: Double): Double

Знаки

Для signum извлеките знак значения. Результаты равны -1, 0 или 1. Обратите внимание, что signum методы не являются чистыми переадресаторами для версий Java. В частности, тип возвращаемого значения java.lang.Long.signum равен Int, но здесь он расширен до Long, чтобы каждый перегруженный вариант возвращал тот же числовой тип, который ему передается.

Исходный код

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

Исходный код

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

Исходный код

def signum(x: Int): Int

Исходный код

def signum(x: Long): Long

Исходный код

def signum(x: Float): Float

Исходный код

def signum(x: Double): Double

Извлечение корней

Исходный код

def cbrt(x: Double): Double

Возвращает кубический корень заданного Double значения.

Исходный код

def sqrt(x: Double): Double

Возвращает квадратный корень из Double значения.

Полярные координаты

Исходный код

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

Преобразует прямоугольные координаты (x, y) в полярные (r, theta).

Исходный код

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

Возвращает квадратный корень из суммы квадратов обоих заданных Double значений без промежуточного понижения или переполнения.

Компонент r точки (r, theta) в полярных координатах, соответствующий точке (x, y) в декартовых координатах.

Единица наименьшей точности

Исходный код

def ulp(x: Double): Double

Возвращает размер ulp заданного Double значения.

Исходный код

def ulp(x: Float): Float

Возвращает размер ulp заданного Float значения.

Генерация псевдослучайных чисел

Исходный код

def random(): Double

Возвращает значение Double с положительным знаком, большее или равное 0.0 и меньшее чем 1.0.

Точная арифметика

Целочисленные сложение, умножение, приращение и преобразование, выбрасывающие ArithmeticException вместо переполнения или подполнения

Источник

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

Источник

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

Источник

def addExact(x: Long, y: Long): Long

Источник

def decrementExact(x: Int): Int

Источник

def decrementExact(x: Long): Long

Источник

def incrementExact(x: Int): Int

Источник

def incrementExact(x: Long): Long

Источник

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

Источник

def multiplyExact(x: Long, y: Long): Long

Источник

def negateExact(x: Int): Int

Источник

def negateExact(x: Long): Long

Источник

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

Источник

def subtractExact(x: Long, y: Long): Long

Источник

def toIntExact(x: Long): Int

Модуль и частное

Вычисление значений частного путем округления до отрицательной бесконечности

Источник

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

Источник

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

Источник

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

Источник

def floorMod(x: Long, y: Long): Long

Смежные числа с плавающей запятой

Источник

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

Источник

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

Источник

def nextDown(d: Double): Double

Источник

def nextDown(f: Float): Float

Источник

def nextUp(d: Double): Double

Источник

def nextUp(f: Float): Float

Классы

Источник

object BigDecimal

Источник

final class BigDecimal(val bigDecimal: BigDecimal, val mc: MathContext) extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[BigDecimal]

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 всегда определяет степень округления (если таковое требуется) и является тем, который распространяется через арифметические операции, сами по себе не применяющие округление.

Источник

объект BigInt

Источник

final класс BigInt extends ScalaNumber with ScalaNumericConversions with Serializable with Ordered[BigInt]

Тип с эффективным кодированием произвольных целых чисел.

Он оборачивает java.math.BigInteger, с оптимизацией для малых значений, которые могут быть закодированы в Long.

Источник

трайт Equiv[T] extends Serializable

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

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

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

2. симметричным: equiv(x, y) == equiv(y, x) для любых x и y типа T.

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

Источник

объект Equiv extends LowPriorityEquiv

Источник

трайт Fractional[T] extends Numeric[T]

Источник

объект Fractional

Источник

трайт Integral[T] extends Numeric[T]

Источник

объект Integral

Источник

трайт LowPriorityEquiv

Источник

трайт LowPriorityOrderingImplicits

Источник

объект Numeric

Источник

трайт Numeric[T] extends Ordering[T]

Источник

трайт Ordered[A] extends Comparable[A]

Трейт для данных, имеющих единое естественное упорядочение. См. 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], вы должны предоставить его самостоятельно, либо при наследовании, либо при создании экземпляра.

Источник

объект Ordered

Источник@implicitNotFound(msg = "No implicit Ordering defined for ${T}.")

трайт Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable

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, compare(a: T, b: T): Int, который определяет, как упорядочить два экземпляра 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 оба предоставляют неявные значения, позволяющие использовать их взаимозаменяемо.

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

Источник

объект Ordering extends LowPriorityOrderingImplicits

Это объект-компаньон для тракта scala.math.Ordering.

Он содержит множество неявных упорядочений, а также методы для создания новых упорядочений.

Исходный код

тракт PartialOrdering[T] extends Equiv[T]

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

Частичный порядок — это бинарное отношение на типе 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.

Исходный код

объект PartialOrdering

Исходный код

тракт PartiallyOrdered[+A]

Класс для данных с частичным порядком.

Исходный код

тракт ScalaNumericAnyConversions

Преобразования, которые предоставляют согласованный интерфейс преобразования для всех числовых типов, подходящий для использования в классах значений.

Исходный код

тракт ScalaNumericConversions extends ScalaNumber with ScalaNumericAnyConversions

Тракт преобразований, несколько более специализированный для классов, которые расширяют ScalaNumber (исключая классы значений).