Класс Math

public final class Math
extends Object

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

В отличие от некоторых числовых методов класса StrictMath, все реализации эквивалентных функций класса Math не определены для возвращения точно одинаковых результатов. Это ослабление позволяет использовать более эффективные реализации, где строгая воспроизводимость не требуется.

По умолчанию многие из Math методов просто вызывают эквивалентный метод в StrictMath для своей реализации. Генераторы кода рекомендуют использовать платформенно-специфичные нативные библиотеки или инструкции микропроцессора, где это возможно, чтобы обеспечить более производительные реализации методов Math. Такие более производительные реализации по-прежнему должны соответствовать спецификации для Math.

Качество реализуемых спецификаций касается двух свойств: точности возвращаемого результата и монотонности метода. Точность плавающей точки Math методов измеряется в единицах в последнем разряде (ulp). Для заданного формата с плавающей точкой ulp определённого действительного числового значения представляет собой расстояние между двумя значениями с плавающей точкой, которые охватывают это числовое значение. При обсуждении точности метода в целом, а не в конкретной точке, приводимое число ulps относится к наихудшему случаю ошибки в любой точке. Если метод всегда имеет ошибку менее 0,5 ulps, метод всегда возвращает число с плавающей точкой, наиболее близкое к точному результату; такой метод называется правильно округленным. Правильно округленный метод, как правило, является наилучшим приближением с плавающей точкой; однако для многих методов с плавающей точкой правильно округленные методы являются непрактичными. Вместо этого для класса Math допускается большая погрешность в 1 или 2 ulps для определённых методов. Неформально, с погрешностью в 1 ulp, когда точный результат является представимым числом, точный результат должен быть возвращён как вычисленный результат; в противном случае, могут быть возвращены любое из двух чисел с плавающей точкой, которые обрамляют точный результат. Для точных результатов большой величины одним из крайних значений обрамления может быть бесконечность. Помимо точности в отдельных точках, также важно поддерживать надлежащие отношения между методом в различных точках. Поэтому большинство методов с ошибками более 0,5 ulp должны быть полумонотонными: когда математическая функция является неубывающей, так же является и приближение с плавающей точкой, аналогично, когда математическая функция является невозрастающей, так же является и приближение с плавающей точкой. Не все приближения, обладающие точностью 1 ulp, автоматически удовлетворяют требованиям монотонности.

Платформа использует целочисленную арифметику со знаком дополнения до двух с int и long примитивными типами. Разработчик должен выбрать примитивный тип, чтобы гарантировать, что арифметические операции последовательно производят правильные результаты, что в некоторых случаях означает, что операции не будут переполнять диапазон значений вычисления. Лучшей практикой является выбор примитивного типа и алгоритма для предотвращения переполнения. В случаях, когда размер int или long и необходимо обнаружить ошибки переполнения, методы addExact, subtractExact, multiplyExact, и toIntExact выбрасывают исключение ArithmeticException при переполнении результатов. Для других арифметических операций, таких как деление, абсолютное значение, увеличение на единицу, уменьшение на единицу и отрицание, переполнение происходит только со значением минимума или максимума и должно быть проверено в зависимости от минимума или максимума.

С тех пор:
1.0

Поля

Модификатор и тип Поле Описание
static double E

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

Значение double, которое ближе всего к π, отношению окружности круга к его диаметру.

Методы

Модификатор и тип Метод Описание
static double abs​(double a)

Возвращает абсолютное значение double значения.
static float abs​(float a)

Возвращает абсолютное значение float значения.
static int abs​(int a)

Возвращает абсолютное значение int значения.
static long abs​(long a)

Возвращает абсолютное значение long значения.
static double acos​(double a)

Возвращает арккосинус значения; возвращаемый угол находится в диапазоне от 0,0 до π.
static int addExact​(int x, int y)

Возвращает сумму своих аргументов, выбросив исключение, если результат выходит за пределы int.
static long addExact​(long x, long y)

Возвращает сумму своих аргументов, выбросив исключение, если результат выходит за пределы long.
static double asin​(double a)

Возвращает арксинус значения; возвращаемый угол находится в диапазоне от -π/2 до π/2.
static double atan​(double a)

Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от -π/2 до π/2.
static double atan2​(double y, double x)

Возвращает угол θ из преобразования прямоугольных координат (x, y) в полярные координаты (r, θ).
static double cbrt​(double a)

Возвращает кубический корень из double значения.
static double ceil​(double a)

Возвращает наименьшее (ближайшее к отрицательной бесконечности) double значение, которое больше или равно аргументу и равно математическому целому числу.
static double copySign​(double magnitude, double sign)

Возвращает первый с плавающей точкой аргумент со знаком второго аргумента с плавающей точкой.
static float copySign​(float magnitude, float sign)

Возвращает первый с плавающей точкой аргумент со знаком второго аргумента с плавающей точкой.
static double cos​(double a)

Возвращает тригонометрический косинус угла.
static double cosh​(double x)

Возвращает гиперболический косинус double значения.
static int decrementExact​(int a)

Возвращает аргумент, уменьшенный на единицу, выбросив исключение, если результат выходит за пределы int.
static long decrementExact​(long a)

Возвращает аргумент, уменьшенный на единицу, выбросив исключение, если результат выходит за пределы long.
static double exp​(double a)

Возвращает число Эйлера e, возведенное в степень double значения.
static double expm1​(double x)

Возвращает ex -1.
static double floor​(double a)

Возвращает наибольшее (ближайшее к положительной бесконечности) double значение, которое меньше или равно аргументу и равно математическому целому числу.
static int floorDiv​(int x, int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) int значение, которое меньше или равно алгебраическому частному.
static long floorDiv​(long x, int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, которое меньше или равно алгебраическому частному.
static long floorDiv​(long x, long y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, которое меньше или равно алгебраическому частному.
static int floorMod​(int x, int y)

Возвращает модуль от деления по полу для int аргументов.
static int floorMod​(long x, int y)

Возвращает модуль от деления по полу для long и int аргументов.
static long floorMod​(long x, long y)

Возвращает модуль от деления по полу для long аргументов.
static double fma​(double a, double b, double c)

Возвращает суммарное произведение-сложение трёх аргументов; то есть возвращает точное произведение первых двух аргументов, складывает его с третьим аргументом и затем округляет один раз до ближайшего double.
static float fma​(float a, float b, float c)

Возвращает суммарное произведение-сложение трёх аргументов; то есть возвращает точное произведение первых двух аргументов, складывает его с третьим аргументом и затем округляет один раз до ближайшего float.
static int getExponent​(double d)

Возвращает несмещённый экспоненту, используемый в представлении double.
static int getExponent​(float f)

Возвращает несмещённый экспоненту, используемый в представлении float.
static double hypot​(double x, double y)

Возвращает sqrt(x2 +y2) без промежуточного переполнения или потери точности.
static double IEEEremainder​(double f1, double f2)

Вычисляет операцию остатка для двух аргументов, как предписано стандартом IEEE 754.
static int incrementExact​(int a)

Возвращает аргумент, увеличенный на единицу, выбросив исключение, если результат выходит за пределы int.
static long incrementExact​(long a)

Возвращает аргумент, увеличенный на единицу, выбросив исключение, если результат выходит за пределы long.
static double log​(double a)

Возвращает натуральный логарифм (по основанию e) double значения.
static double log10​(double a)

Возвращает логарифм по основанию 10 double значения.
static double log1p​(double x)

Возвращает натуральный логарифм суммы аргумента и 1.
static double max​(double a, double b)

Возвращает большее из двух double значений.
static float max​(float a, float b)

Возвращает большее из двух float значений.
static int max​(int a, int b)

Возвращает большее из двух int значений.
static long max​(long a, long b)

Возвращает большее из двух long значений.
static double min​(double a, double b)

Возвращает меньшее из двух double значений.
static float min​(float a, float b)

Возвращает меньшее из двух float значений.
static int min​(int a, int b)

Возвращает меньшее из двух int значений.
static long min​(long a, long b)

Возвращает меньшее из двух long значений.
static int multiplyExact​(int x, int y)

Возвращает произведение аргументов, выбросив исключение, если результат выходит за пределы int.
static long multiplyExact​(long x, int y)

Возвращает произведение аргументов, выбросив исключение, если результат выходит за пределы long.
static long multiplyExact​(long x, long y)

Возвращает произведение аргументов, выбросив исключение, если результат выходит за пределы long.
static long multiplyFull​(int x, int y)

Возвращает точное математическое произведение аргументов.
static long multiplyHigh​(long x, long y)

Возвращает в виде long наиболее значимые 64 бита 128-битного произведения двух 64-битных множителей.
static int negateExact​(int a)

Возвращает отрицание аргумента, выбросив исключение, если результат выходит за пределы int.
static long negateExact​(long a)

Возвращает отрицание аргумента, выбросив исключение, если результат выходит за пределы long.
static double nextAfter​(double start, double direction)

Возвращает число с плавающей точкой, прилежащее к первому аргументу в направлении второго аргумента.
static float nextAfter​(float start, double direction)

Возвращает число с плавающей запятой, смежное с первым аргументом в направлении второго аргумента.
static double nextDown​(double d)

Возвращает значение с плавающей запятой, смежное с d в направлении минус бесконечности.
static float nextDown​(float f)

Возвращает значение с плавающей запятой, смежное с f в направлении минус бесконечности.
static double nextUp​(double d)

Возвращает значение с плавающей запятой, смежное с d в направлении плюс бесконечности.
static float nextUp​(float f)

Возвращает значение с плавающей запятой, смежное с f в направлении плюс бесконечности.
static double pow​(double a, double b)

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

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

static double rint​(double a)

Возвращает значение с плавающей запятой, наиболее близкое по значению к аргументу и равное математическому целому числу.
static long round​(double a)

Возвращает ближайшее long к аргументу, при равенстве округляет до плюс бесконечности.
static int round​(float a)

Возвращает ближайшее int к аргументу, при равенстве округляет до плюс бесконечности.
static double scalb​(double d, int scaleFactor)

Возвращает d × 2scaleFactor, округленное так, как если бы оно выполнялось с помощью одного корректно округлённого умножения с плавающей запятой до значения в множестве двойных значений.
static float scalb​(float f, int scaleFactor)

Возвращает f × 2scaleFactor, округленное так, как если бы оно выполнялось с помощью одного корректно округлённого умножения с плавающей запятой до значения в множестве значений с плавающей запятой одинарной точности.
static double signum​(double d)

Возвращает функцию знака аргумента; ноль, если аргумент равен нулю, 1.0, если аргумент больше нуля, -1.0, если аргумент меньше нуля.
static float signum​(float f)

Возвращает функцию знака аргумента; ноль, если аргумент равен нулю, 1.0f, если аргумент больше нуля, -1.0f, если аргумент меньше нуля.
static double sin​(double a)

Возвращает тригонометрический синус угла.
static double sinh​(double x)

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

static double sqrt​(double a)

Возвращает корректно округлённый положительный квадратный корень из значения double.

static int subtractExact​(int x, int y)

Возвращает разность аргументов, выбрасывая исключение, если результат выходит за пределы int.
static long subtractExact​(long x, long y)

Возвращает разность аргументов, выбрасывая исключение, если результат выходит за пределы long.
static double tan​(double a)

Возвращает тригонометрический тангенс угла.
static double tanh​(double x)

Возвращает гиперболический тангенс значения double.
static double toDegrees​(double angrad)

Преобразует угол, измеренный в радианах, в приблизительно эквивалентный угол, измеренный в градусах.
static int toIntExact​(long value)

Возвращает значение аргумента long; выбрасывая исключение, если значение выходит за пределы int.
static double toRadians​(double angdeg)

Преобразует угол, измеренный в градусах, в приблизительно эквивалентный угол, измеренный в радианах.
static double ulp​(double d)

Возвращает размер единицы наименьшего порядка (ulp) аргумента.
static float ulp​(float f)

Возвращает размер единицы наименьшего порядка (ulp) аргумента.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Поля

E

public static final double E

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

См. также:
Значения постоянных полей

PI

public static final double PI

Значение double, наиболее близкое к π, отношению длины окружности к её диаметру.

См. также:
Значения постоянных полей

Методы

sin

public static double sin(double a)

Возвращает тригонометрический синус угла. Особые случаи:

  • Если аргумент — NaN или бесконечность, результат — NaN.
  • Если аргумент равен нулю, результат — ноль с тем же знаком, что и аргумент.

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

Параметры:
a - угол в радианах.
Возвращает:
синус аргумента.

cos

public static double cos(double a)

Возвращает тригонометрический косинус угла. Особые случаи:

  • Если аргумент — NaN или бесконечность, результат — NaN.

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

Параметры:
a - угол в радианах.
Возвращает:
косинус аргумента.

tan

public static double tan(double a)

Возвращает тригонометрический тангенс угла. Особые случаи:

  • Если аргумент — NaN или бесконечность, результат — NaN.
  • Если аргумент равен нулю, результат — ноль с тем же знаком, что и аргумент.

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

Параметры:
a - угол в радианах.
Возвращает:
тангенс аргумента.

asin

public static double asin(double a)

Возвращает арксинус значения; возвращаемый угол находится в диапазоне от -π/2 до π/2. Особые случаи:

  • Если аргумент — NaN или его абсолютное значение больше 1, результат — NaN.
  • Если аргумент равен нулю, результат — ноль с тем же знаком, что и аргумент.

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

Параметры:
a - значение, для которого требуется найти арксинус.
Возвращает:
арксинус аргумента.

acos

public static double acos(double a)

Возвращает арккосинус значения; возвращаемый угол находится в диапазоне от 0,0 до π. Специальный случай:

  • Если аргумент — NaN или его абсолютное значение больше 1, результат — NaN.

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

Параметры:
a - значение, для которого требуется найти арккосинус.
Возвращает:
арккосинус аргумента.

atan

public static double atan(double a)

Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от -π/2 до π/2. Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент равен нулю, результат — ноль с тем же знаком, что и аргумент.

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

Параметры:
a - значение, для которого требуется найти арктангенс.
Возвращает:
арктангенс аргумента.

toRadians

public static double toRadians(double angdeg)

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

Параметры:
angdeg - угол в градусах
Возвращает:
значение угла angdeg в радианах.
С:
1.2

toDegrees

public static double toDegrees(double angrad)

Преобразует угол, измеренный в радианах, в приблизительно эквивалентный угол, измеренный в градусах. Преобразование из радиан в градусы, как правило, неточно; пользователи не должны ожидать, что cos(toRadians(90.0)) будет точно равно 0.0.

Параметры:
angrad - угол в радианах
Возвращает:
значение угла angrad в градусах.
С:
1.2

exp

public static double exp(double a)

Возвращает число Эйлера e, возведённое в степень double значения. Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — отрицательная бесконечность, результат — положительный ноль.

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

Параметры:
a - показатель степени, в которую нужно возвести e.
Возвращает:
значение ea, где e — основание натуральных логарифмов.

log

public static double log(double a)

Возвращает натуральный логарифм (по основанию e) double значения. Особые случаи:

  • Если аргумент — NaN или меньше нуля, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — положительный или отрицательный ноль, результат — минус бесконечность.

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

Параметры:
a - значение
Возвращает:
значение ln a, натуральный логарифм a.

log10

public static double log10(double a)

Возвращает логарифм по основанию 10 double значения. Особые случаи:

  • Если аргумент — NaN или меньше нуля, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — положительный или отрицательный ноль, результат — минус бесконечность.
  • Если аргумент равен 10n для целого числа n, результат — n.

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

Параметры:
a - значение
Возвращает:
логарифм по основанию 10 a.
С:
1.5

sqrt

public static double sqrt(double a)

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

  • Если аргумент — NaN или меньше нуля, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — положительный или отрицательный ноль, результат такой же, как и аргумент.
В противном случае результат — double значение, наиболее близкое к истинному математическому квадратному корню из значения аргумента.

Параметры:
a - значение.
Возвращает:
положительный квадратный корень из a. Если аргумент — NaN или меньше нуля, результат — NaN.

cbrt

public static double cbrt(double a)

Возвращает кубический корень из double значения. Для положительных конечных x, cbrt(-x) == -cbrt(x); то есть кубический корень из отрицательного значения — это отрицание кубического корня из модуля этого значения. Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент — бесконечность, результат — бесконечность с тем же знаком, что и аргумент.
  • Если аргумент — ноль, результат — ноль с тем же знаком, что и аргумент.

Вычисленный результат должен находиться в пределах 1 ulp от точного результата.

Параметры:
a - значение.
Возвращает:
кубический корень из a.
С:
1.5

IEEEremainder

public static double IEEEremainder(double f1,
                                   double f2)

Вычисляет операцию остатка от деления для двух аргументов, как предписано стандартом IEEE 754. Значение остатка математически равно f1 - f2 × n, где n — ближайшее к точному математическому значению частного f1/f2 целое число, и если два целых числа одинаково близки к f1/f2, то n — чётное число. Если остаток равен нулю, его знак совпадает со знаком первого аргумента. Особые случаи:

  • Если любой из аргументов — NaN, или первый аргумент — бесконечность, или второй аргумент — положительный или отрицательный ноль, то результат — NaN.
  • Если первый аргумент конечен, а второй аргумент — бесконечность, то результат такой же, как первый аргумент.

Параметры:
f1 - делимое.
f2 - делитель.
Возвращает:
остаток от деления f1 на f2.

ceil

public static double ceil(double a)

Возвращает наименьшее (ближайшее к минус бесконечности) double значение, большее или равное аргументу и равное математическому целому числу. Особые случаи:

  • Если значение аргумента уже равно математическому целому числу, результат такой же, как аргумент.
  • Если аргумент — NaN, бесконечность, или положительный или отрицательный ноль, результат такой же, как аргумент.
  • Если значение аргумента меньше нуля, но больше -1,0, результат — отрицательный ноль.
Обратите внимание, что значение Math.ceil(x) точно равно значению -Math.floor(-x).

Параметры:
a - значение.
Возвращает:
наименьшее (ближайшее к минус бесконечности) значение с плавающей запятой, которое больше или равно аргументу и равно математическому целому числу.

floor

public static double floor(double a)

Возвращает наибольшее (ближайшее к положительной бесконечности) double значение, меньшее или равное аргументу и равное математическому целому числу. Особые случаи:

  • Если значение аргумента уже равно математическому целому числу, результат такой же, как аргумент.
  • Если аргумент — NaN, бесконечность, или положительный или отрицательный ноль, результат такой же, как аргумент.

Параметры:
a - значение.
Возвращает:
наибольшее (ближайшее к положительной бесконечности) значение с плавающей запятой, которое меньше или равно аргументу и равно математическому целому числу.

rint

public static double rint(double a)

Возвращает значение double, которое наиболее близко по значению к аргументу и равно математическому целому числу. Если два значения double, которые являются математическими целыми числами, одинаково близки, результат — целое значение, которое является чётным. Специальные случаи:

  • Если значение аргумента уже равно математическому целому числу, то результат такой же, как и аргумент.
  • Если аргумент NaN, бесконечность или положительный или отрицательный ноль, то результат такой же, как и аргумент.

Параметры:
a - значение double.
Возвращает:
наиболее близкое значение с плавающей точкой к a, которое равно математическому целому числу.

atan2

public static double atan2(double y,
                           double x)

Возвращает угол theta из преобразования прямоугольных координат (x, y) в полярные координаты (r, theta). Этот метод вычисляет фазу theta, вычисляя арктангенс y/x в диапазоне от -pi до pi. Специальные случаи:

  • Если любой из аргументов NaN, то результат NaN.
  • Если первый аргумент — положительный ноль, а второй — положительный, или первый аргумент — положительный и конечный, а второй — положительная бесконечность, то результат — положительный ноль.
  • Если первый аргумент — отрицательный ноль, а второй — положительный, или первый аргумент — отрицательный и конечный, а второй — положительная бесконечность, то результат — отрицательный ноль.
  • Если первый аргумент — положительный ноль, а второй — отрицательный, или первый аргумент — положительный и конечный, а второй — отрицательная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к pi.
  • Если первый аргумент — отрицательный ноль, а второй — отрицательный, или первый аргумент — отрицательный и конечный, а второй — отрицательная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к -pi.
  • Если первый аргумент — положительный, а второй — положительный или отрицательный ноль, или первый аргумент — положительная бесконечность, а второй — конечный, то результат — значение с плавающей точкой, наиболее близкое к pi/2.
  • Если первый аргумент — отрицательный, а второй — положительный или отрицательный ноль, или первый аргумент — отрицательная бесконечность, а второй — конечный, то результат — значение с плавающей точкой, наиболее близкое к -pi/2.
  • Если оба аргумента — положительная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к pi/4.
  • Если первый аргумент — положительная бесконечность, а второй — отрицательная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к 3*pi/4.
  • Если первый аргумент — отрицательная бесконечность, а второй — положительная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к -pi/4.
  • Если оба аргумента — отрицательная бесконечность, то результат — значение с плавающей точкой, наиболее близкое к -3*pi/4.

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

Параметры:
y - координата ординаты
x - координата абсциссы
Возвращает:
компонент theta точки (r, theta) в полярных координатах, соответствующей точке (x, y) в декартовых координатах.

pow

public static double pow(double a,
                         double b)

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

  • Если второй аргумент — положительный или отрицательный ноль, то результат — 1.0.
  • Если второй аргумент — 1.0, то результат такой же, как и первый аргумент.
  • Если второй аргумент — NaN, то результат — NaN.
  • Если первый аргумент — NaN, а второй — ненулевой, то результат — NaN.
  • Если
    • абсолютное значение первого аргумента больше 1 и второй аргумент — положительная бесконечность, или
    • абсолютное значение первого аргумента меньше 1 и второй аргумент — отрицательная бесконечность,
    то результат — положительная бесконечность.
  • Если
    • абсолютное значение первого аргумента больше 1 и второй аргумент — отрицательная бесконечность, или
    • абсолютное значение первого аргумента меньше 1 и второй аргумент — положительная бесконечность,
    то результат — положительный ноль.
  • Если абсолютное значение первого аргумента равно 1, а второй аргумент — бесконечность, то результат — NaN.
  • Если
    • первый аргумент — положительный ноль и второй аргумент — больше нуля, или
    • первый аргумент — положительная бесконечность и второй аргумент — меньше нуля,
    то результат — положительный ноль.
  • Если
    • первый аргумент — положительный ноль и второй аргумент — меньше нуля, или
    • первый аргумент — положительная бесконечность и второй аргумент — больше нуля,
    то результат — положительная бесконечность.
  • Если
    • первый аргумент — отрицательный ноль и второй аргумент — больше нуля, но не конечное нечётное целое число, или
    • первый аргумент — отрицательная бесконечность и второй аргумент — меньше нуля, но не конечное нечётное целое число,
    то результат — положительный ноль.
  • Если
    • первый аргумент — отрицательный ноль и второй аргумент — положительное конечное нечётное целое число, или
    • первый аргумент — отрицательная бесконечность и второй аргумент — отрицательное конечное нечётное целое число,
    то результат — отрицательный ноль.
  • Если
    • первый аргумент — отрицательный ноль и второй аргумент — меньше нуля, но не конечное нечётное целое число, или
    • первый аргумент — отрицательная бесконечность и второй аргумент — больше нуля, но не конечное нечётное целое число,
    то результат — положительная бесконечность.
  • Если
    • первый аргумент — отрицательный ноль и второй аргумент — отрицательное конечное нечётное целое число, или
    • первый аргумент — отрицательная бесконечность и второй аргумент — положительное конечное нечётное целое число,
    то результат — отрицательная бесконечность.
  • Если первый аргумент конечный и меньше нуля
    • если второй аргумент — конечное чётное целое число, результат равен результату возведения абсолютного значения первого аргумента в степень второго аргумента
    • если второй аргумент — конечное нечётное целое число, результат равен отрицательному результату возведения абсолютного значения первого аргумента в степень второго аргумента
    • если второй аргумент — конечный и не является целым числом, то результат — NaN.
  • Если оба аргумента — целые числа, то результат точно равен математическому результату возведения первого аргумента в степень второго аргумента, если этот результат может быть точно представлен как значение с плавающей точкой.

(В описаниях выше, значение с плавающей точкой считается целым числом только в том случае, если оно конечно и является неподвижной точкой метода ceil или, что эквивалентно, неподвижной точкой метода floor. Значение является неподвижной точкой одноаргументного метода, если и только если результат применения метода к значению равен значению.)

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

Параметры:
a - основание.
b - показатель степени.
Возвращает:
значение ab.

round

public static int round(float a)

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

Специальные случаи:

  • Если аргумент NaN, результат — 0.
  • Если аргумент — отрицательная бесконечность или любое значение, меньшее или равное значению Integer.MIN_VALUE, результат равен значению Integer.MIN_VALUE.
  • Если аргумент — положительная бесконечность или любое значение, большее или равное значению Integer.MAX_VALUE, результат равен значению Integer.MAX_VALUE.
Параметры:
a - значение с плавающей точкой, которое должно быть округлено до целого числа.
Возвращает:
значение аргумента, округлённого до ближайшего значения с плавающей точкой.
См. также:
Integer.MAX_VALUE, Integer.MIN_VALUE

round

public static long round(double a)

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

Специальные случаи:

  • Если аргумент NaN, результат — 0.
  • Если аргумент — отрицательная бесконечность или любое значение, меньшее или равное значению Long.MIN_VALUE, результат равен значению Long.MIN_VALUE.
  • Если аргумент — положительная бесконечность или любое значение, большее или равное значению Long.MAX_VALUE, результат равен значению Long.MAX_VALUE.
Параметры:
a - значение с плавающей точкой, которое должно быть округлено до целого.
Возвращает:
значение аргумента, округлённого до ближайшего значения с плавающей точкой.
См. также:
Long.MAX_VALUE, Long.MIN_VALUE

random

public static double random()

Возвращает значение с плавающей точкой с положительным знаком, большее или равное 0.0 и меньшее 1.0. Возвращаемые значения выбираются псевдослучайным образом с (приблизительно) равномерным распределением из этого диапазона.

При первом вызове этого метода он создаёт один новый генератор псевдослучайных чисел, точно так же, как и в выражении 

new java.util.Random()
Этот новый генератор псевдослучайных чисел используется в дальнейшем для всех вызовов этого метода и нигде более.

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

Примечание API:
Так как наибольшее значение с плавающей точкой, меньшее 1.0, равно Math.nextDown(1.0), значение x в замкнутом диапазоне [x1,x2], где x1<=x2 может быть определено утверждениями 
double f = Math.random()/Math.nextDown(1.0);
double x = x1*(1.0 - f) + x2*f;
Возвращает:
псевдослучайное значение с плавающей точкой, большее или равное 0.0 и меньшее 1.0.
См. также:
nextDown(double), Random.nextDouble()

addExact

public static int addExact(int x,
                           int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

addExact

public static long addExact(long x,
                            long y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

subtractExact

public static int subtractExact(int x,
                                int y)

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

Параметры:
x - первое значение
y - второе значение для вычитания из первого
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

subtractExact

public static long subtractExact(long x,
                                 long y)

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

Параметры:
x - первое значение
y - второе значение для вычитания из первого
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

multiplyExact

public static int multiplyExact(int x,
                                int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

multiplyExact

public static long multiplyExact(long x,
                                 int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
9

multiplyExact

public static long multiplyExact(long x,
                                 long y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

incrementExact

public static int incrementExact(int a)

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

Параметры:
a - значение для увеличения
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

incrementExact

public static long incrementExact(long a)

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

Параметры:
a - значение для увеличения
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

decrementExact

public static int decrementExact(int a)

Возвращает аргумент, уменьшенный на единицу, выбрасывая исключение, если результат выходит за пределы int.

Параметры:
a - значение для уменьшения
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

decrementExact

public static long decrementExact(long a)

Возвращает аргумент, уменьшенный на единицу, выбрасывая исключение, если результат выходит за пределы long.

Параметры:
a - значение для уменьшения
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

negateExact

public static int negateExact(int a)

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

Параметры:
a - значение для отрицания
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы int
С:
1.8

negateExact

public static long negateExact(long a)

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

Параметры:
a - значение для отрицания
Возвращает:
результат
Исключения:
ArithmeticException - если результат выходит за пределы long
С:
1.8

toIntExact

public static int toIntExact(long value)

Возвращает значение аргумента long; выбрасывая исключение, если значение выходит за пределы int.

Параметры:
value - значение long
Возвращает:
аргумент как int
Исключения:
ArithmeticException - если значение argument выходит за пределы int
С:
1.8

multiplyFull

public static long multiplyFull(int x,
                                int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
С:
9

multiplyHigh

public static long multiplyHigh(long x,
                                long y)

Возвращает как long самые старшие 64 бита 128-битного произведения двух 64-битных сомножителей.

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
С:
9

floorDiv

public static int floorDiv(int x,
                           int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) int значение, меньшее или равное алгебраическому частному. Есть один особый случай, если делимое равно Integer.MIN_VALUE, а делитель -1, то происходит переполнение целого числа, и результат равен Integer.MIN_VALUE.

Обычное целочисленное деление работает в режиме округления до нуля (обрезание). Эта операция вместо этого действует в режиме округления до отрицательной бесконечности (пол). Режим округления до пола дает разные результаты, чем обрезка, когда точный результат отрицательный.

  • Если знаки аргументов одинаковые, результаты floorDiv и оператора / одинаковые.
    Например, floorDiv(4, 3) == 1 и (4 / 3) == 1.
  • Если знаки аргументов разные, частное отрицательное и floorDiv возвращает целое число, меньшее или равное частному, а оператор / возвращает целое число, наиболее близкое к нулю.
    Например, floorDiv(-4, 3) == -2, тогда как (-4 / 3) == -1.
Параметры:
x - делимое
y - делитель
Возвращает:
наибольшее (ближайшее к положительной бесконечности) int значение, меньшее или равное алгебраическому частному.
Исключения:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
floorMod(int, int), floor(double)

floorDiv

public static long floorDiv(long x,
                            int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, меньшее или равное алгебраическому частному. Есть один особый случай, если делимое равно Long.MIN_VALUE, а делитель -1, то происходит переполнение целого числа, и результат равен Long.MIN_VALUE.

Обычное целочисленное деление работает в режиме округления до нуля (обрезание). Эта операция вместо этого действует в режиме округления до отрицательной бесконечности (пол). Режим округления до пола дает разные результаты, чем обрезка, когда точный результат отрицательный.

Примеры см. в floorDiv(int, int).

Параметры:
x - делимое
y - делитель
Возвращает:
наибольшее (ближайшее к положительной бесконечности) int значение, меньшее или равное алгебраическому частному.
Исключения:
ArithmeticException - если делитель y равен нулю
С:
9
См. также:
floorMod(long, int), floor(double)

floorDiv

public static long floorDiv(long x,
                            long y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, меньшее или равное алгебраическому частному. Есть один особый случай, если делимое равно Long.MIN_VALUE, а делитель -1, то происходит переполнение целого числа, и результат равен Long.MIN_VALUE.

Обычное целочисленное деление работает в режиме округления до нуля (обрезание). Эта операция вместо этого действует в режиме округления до отрицательной бесконечности (пол). Режим округления до пола дает разные результаты, чем обрезка, когда точный результат отрицательный.

Примеры см. в floorDiv(int, int).

Параметры:
x - делимое
y - делитель
Возвращает:
наибольшее (ближайшее к положительной бесконечности) long значение, которое меньше или равно алгебраическому частному.
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
floorMod(long, long), floor(double)

floorMod

public static int floorMod(int x,
                           int y)

Возвращает остаток от деления по методу floor для int аргументов.

Остаток от деления по методу floor x - (floorDiv(x, y) * y), имеет тот же знак, что и делитель y, и находится в диапазоне -abs(y) < r < +abs(y).

Связь между floorDiv и оператором floorMod такова:

  • floorDiv(x, y) * y + floorMod(x, y) == x

Разница в значениях между floorMod и оператором % обусловлена разницей между floorDiv (возвращает целое число, меньшее или равное частному) и оператором / (возвращает целое число, ближайшее к нулю).

Примеры:

  • Если знаки аргументов одинаковые, результаты floorMod и оператора % совпадают.
    • floorMod(4, 3) == 1; и (4 % 3) == 1
  • Если знаки аргументов разные, результаты отличаются от результата оператора %.
    • floorMod(+4, -3) == -2; и (+4 % -3) == +1
    • floorMod(-4, +3) == +2; и (-4 % +3) == -1
    • floorMod(-4, -3) == -1; и (-4 % -3) == -1

Если знаки аргументов неизвестны, и нужен положительный остаток, он может быть вычислен как (floorMod(x, y) + abs(y)) % abs(y).

Параметры:
x - делимое
y - делитель
Возвращает:
остаток от деления по методу floor x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
floorDiv(int, int)

floorMod

public static int floorMod(long x,
                           int y)

Возвращает остаток от деления по методу floor для long и int аргументов.

Остаток от деления по методу floor x - (floorDiv(x, y) * y), имеет тот же знак, что и делитель y, и находится в диапазоне -abs(y) < r < +abs(y).

Связь между floorDiv и floorMod такова:

  • floorDiv(x, y) * y + floorMod(x, y) == x

Примеры см. в floorMod(int, int).

Параметры:
x - делимое
y - делитель
Возвращает:
остаток от деления по методу floor x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
9
См. также:
floorDiv(long, int)

floorMod

public static long floorMod(long x,
                            long y)

Возвращает остаток от деления по методу floor для long аргументов.

Остаток от деления по методу floor x - (floorDiv(x, y) * y), имеет тот же знак, что и делитель y, и находится в диапазоне -abs(y) < r < +abs(y).

Связь между floorDiv и floorMod такова:

  • floorDiv(x, y) * y + floorMod(x, y) == x

Примеры см. в floorMod(int, int).

Параметры:
x - делимое
y - делитель
Возвращает:
остаток от деления по методу floor x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
floorDiv(long, long)

abs

public static int abs(int a)

Возвращает абсолютное значение целого числа int. Если аргумент не отрицательный, возвращает сам аргумент. Если аргумент отрицательный, возвращает его отрицание.

Обратите внимание, что если аргумент равен значению Integer.MIN_VALUE, самому отрицательному представляемому int значению, то результат будет тем же самым значением, которое отрицательное.

Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

abs

public static long abs(long a)

Возвращает абсолютное значение long значения. Если аргумент не отрицательный, возвращает сам аргумент. Если аргумент отрицательный, возвращает его отрицание.

Обратите внимание, что если аргумент равен значению Long.MIN_VALUE, самому отрицательному представляемому long значению, то результат будет тем же самым значением, которое отрицательное.

Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

abs

public static float abs(float a)

Возвращает абсолютное значение float значения. Если аргумент не отрицательный, возвращает сам аргумент. Если аргумент отрицательный, возвращает его отрицание. Особые случаи:

  • Если аргумент равен положительному или отрицательному нулю, результат — положительный ноль.
  • Если аргумент равен бесконечности, результат — положительная бесконечность.
  • Если аргумент — NaN, результат — NaN.

Примечание API:
Как следует из вышеизложенного, одно из допустимых реализаций этого метода задано выражением ниже, которое вычисляет float с тем же показателем и мантиссой, что и аргумент, но с гарантированным нулевым битом знака, указывающим положительное значение:
Float.intBitsToFloat(0x7fffffff & Float.floatToRawIntBits(a))
Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

abs

public static double abs(double a)

Возвращает абсолютное значение double значения. Если аргумент не отрицательный, возвращает сам аргумент. Если аргумент отрицательный, возвращает его отрицание. Особые случаи:

  • Если аргумент равен положительному или отрицательному нулю, результат — положительный ноль.
  • Если аргумент равен бесконечности, результат — положительная бесконечность.
  • Если аргумент — NaN, результат — NaN.

Примчание API:
Как следует из вышеизложенного, одно из допустимых реализаций этого метода задано выражением ниже, которое вычисляет double с тем же показателем и мантиссой, что и аргумент, но с гарантированным нулевым битом знака, указывающим положительное значение:
Double.longBitsToDouble((Double.doubleToRawLongBits(a)<<1)>>>1)
Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

max

public static int max(int a,
                      int b)

Возвращает большее из двух int значений. То есть, результат — аргумент, более близкий к значению Integer.MAX_VALUE. Если аргументы имеют одинаковое значение, результат — это же значение.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
большее из a и b.

max

public static long max(long a,
                       long b)

Возвращает большее из двух long значений. То есть, результат — аргумент, более близкий к значению Long.MAX_VALUE. Если аргументы имеют одинаковое значение, результат — это же значение.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
большее из a и b.

max

public static float max(float a,
                        float b)

Возвращает большее из двух float значений. То есть, результат — аргумент, более близкий к положительной бесконечности. Если аргументы имеют одинаковое значение, результат — это же значение. Если какое-либо значение равно NaN, результат — NaN. В отличие от операторов числового сравнения, этот метод рассматривает отрицательный ноль как строго меньший, чем положительный ноль. Если один аргумент равен положительному нулю, а другой — отрицательному нулю, результат — положительный ноль.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
большее из a и b.

max

public static double max(double a,
                         double b)

Возвращает большее из двух double значений. То есть, результат — аргумент, более близкий к положительной бесконечности. Если аргументы имеют одинаковое значение, результат — это же значение. Если какое-либо значение равно NaN, результат — NaN. В отличие от операторов числового сравнения, этот метод рассматривает отрицательный ноль как строго меньший, чем положительный ноль. Если один аргумент равен положительному нулю, а другой — отрицательному нулю, результат — положительный ноль.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
большее из a и b.

min

public static int min(int a,
                      int b)

Возвращает меньшее из двух int значений. То есть, результат — аргумент, более близкий к значению Integer.MIN_VALUE. Если аргументы имеют одинаковое значение, результат — это же значение.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
меньшее из a и b.

min

public static long min(long a,
                       long b)

Возвращает меньшее из двух long значений. То есть, результат — аргумент, более близкий к значению Long.MIN_VALUE. Если аргументы имеют одинаковое значение, результат — это же значение.

Параметры:
a - аргумент.
b - другой аргумент.
Возвращает:
меньшее из a и b.

min

public static float min(float a,
                        float b)

Возвращает меньшее из двух float значений. То есть, результат — значение, более близкое к отрицательной бесконечности. Если аргументы имеют одинаковое значение, результат — это то же самое значение. Если любое из значений равно NaN, то результатом будет NaN. В отличие от числовых операторов сравнения, этот метод рассматривает отрицательный ноль как строго меньший, чем положительный ноль. Если один аргумент равен положительному нулю, а другой — отрицательному нулю, результатом является отрицательный ноль.

Параметры:
a — аргумент.
b — другой аргумент.
Возвращает:
меньшее из a и b.

min

public static double min(double a,
                         double b)

Возвращает меньшее из двух double значений. То есть, результат — значение, более близкое к отрицательной бесконечности. Если аргументы имеют одинаковое значение, результат — это то же самое значение. Если любое из значений равно NaN, то результатом будет NaN. В отличие от числовых операторов сравнения, этот метод рассматривает отрицательный ноль как строго меньший, чем положительный ноль. Если один аргумент равен положительному нулю, а другой — отрицательному нулю, результатом является отрицательный ноль.

Параметры:
a — аргумент.
b — другой аргумент.
Возвращает:
меньшее из a и b.

fma

public static double fma(double a,
                         double b,
                         double c)

Возвращает результат операции умножения и сложения трёх аргументов; то есть, возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, и затем округлённое один раз до ближайшего double. Округление выполняется с использованием режима округления до ближайшего чётного. В отличие от этого, если a * b + c вычисляется как обычное выражение с плавающей точкой, происходят две ошибки округления, первая для операции умножения, вторая для операции сложения.

Особые случаи:

  • Если любой из аргументов равен NaN, результат равен NaN.
  • Если один из первых двух аргументов равен бесконечности, а другой — нулю, результат равен NaN.
  • Если точное произведение первых двух аргументов равно бесконечности (иначе говоря, по крайней мере один из аргументов равен бесконечности, а другой не равен нулю и не является NaN) и третий аргумент — бесконечность противоположного знака, результат равен NaN.

Обратите внимание, что fma(a, 1.0, c) возвращает тот же результат, что и (a + c). Однако, fma(a, b, +0.0) не всегда возвращает тот же результат, что и (a * b) так как fma(-0.0, +0.0, +0.0) является +0.0, в то время как (-0.0 * +0.0) является -0.0; однако fma(a, b, -0.0) эквивалентно (a * b).

Примечание API:
Этот метод соответствует операции fusedMultiplyAdd, определенной в IEEE 754-2008.
Параметры:
a — значение
b — значение
c — значение
Возвращает:
(a × b + c), вычисленный, как если бы с неограниченным диапазоном и точностью, и округлённый один раз до ближайшего double значения
С версии:
9

fma

public static float fma(float a,
                        float b,
                        float c)

Возвращает результат операции умножения и сложения трёх аргументов; то есть, возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, и затем округлённое один раз до ближайшего float. Округление выполняется с использованием режима округления до ближайшего чётного. В отличие от этого, если a * b + c вычисляется как обычное выражение с плавающей точкой, происходят две ошибки округления, первая для операции умножения, вторая для операции сложения.

Особые случаи:

  • Если любой из аргументов равен NaN, результат равен NaN.
  • Если один из первых двух аргументов равен бесконечности, а другой — нулю, результат равен NaN.
  • Если точное произведение первых двух аргументов равно бесконечности (иначе говоря, по крайней мере один из аргументов равен бесконечности, а другой не равен нулю и не является NaN) и третий аргумент — бесконечность противоположного знака, результат равен NaN.

Обратите внимание, что fma(a, 1.0f, c) возвращает тот же результат, что и (a + c). Однако, fma(a, b, +0.0f) не всегда возвращает тот же результат, что и (a * b) так как fma(-0.0f, +0.0f, +0.0f) является +0.0f, в то время как (-0.0f * +0.0f) является -0.0f; однако fma(a, b, -0.0f) эквивалентно (a * b).

Примечание API:
Этот метод соответствует операции fusedMultiplyAdd, определенной в IEEE 754-2008.
Параметры:
a — значение
b — значение
c — значение
Возвращает:
(a × b + c), вычисленный, как если бы с неограниченным диапазоном и точностью, и округлённый один раз до ближайшего float значения
С версии:
9

ulp

public static double ulp(double d)

Возвращает размер ulp аргумента. Ulp, единица в последнем разряде, значения с плавающей точкой, — это положительное расстояние между этим значением с плавающей точкой и double значением, следующим по величине. Обратите внимание, что для не-NaN x, ulp(-x) == ulp(x).

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен положительной или отрицательной бесконечности, то результат равен положительной бесконечности.
  • Если аргумент равен положительному или отрицательному нулю, то результат равен Double.MIN_VALUE.
  • Если аргумент равен ±Double.MAX_VALUE, то результат равен 2971.
Параметры:
d — значение с плавающей точкой, ulp которого нужно вернуть
Возвращает:
размер ulp аргумента
С версии:
1.5

ulp

public static float ulp(float f)

Возвращает размер ulp аргумента. Ulp, единица в последнем разряде, значения с плавающей точкой, — это положительное расстояние между этим значением с плавающей точкой и float значением, следующим по величине. Обратите внимание, что для не-NaN x, ulp(-x) == ulp(x).

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен положительной или отрицательной бесконечности, то результат равен положительной бесконечности.
  • Если аргумент равен положительному или отрицательному нулю, то результат равен Float.MIN_VALUE.
  • Если аргумент равен ±Float.MAX_VALUE, то результат равен 2104.
Параметры:
f — значение с плавающей точкой, ulp которого нужно вернуть
Возвращает:
размер ulp аргумента
С версии:
1.5

signum

public static double signum(double d)

Возвращает функцию signum аргумента; ноль, если аргумент равен нулю, 1.0, если аргумент больше нуля, -1.0, если аргумент меньше нуля.

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен положительному или отрицательному нулю, то результат такой же, как и аргумент.
Параметры:
d — значение с плавающей точкой, signum которого нужно вернуть
Возвращает:
функция signum аргумента
С версии:
1.5

signum

public static float signum(float f)

Возвращает функцию signum аргумента; ноль, если аргумент равен нулю, 1.0f, если аргумент больше нуля, -1.0f, если аргумент меньше нуля.

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен положительному или отрицательному нулю, то результат такой же, как и аргумент.
Параметры:
f — значение с плавающей точкой, signum которого нужно вернуть
Возвращает:
функция signum аргумента
С версии:
1.5

sinh

public static double sinh(double x)

Возвращает гиперболический синус значения с плавающей точкой. Гиперболический синус x определяется как (ex - e-x)/2, где e — число Эйлера.

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен бесконечности, то результат — бесконечность с тем же знаком, что и аргумент.
  • Если аргумент равен нулю, то результат — ноль с тем же знаком, что и аргумент.

Вычисленный результат должен находиться в пределах 2.5 ulps от точного результата.

Параметры:
x — число, гиперболический синус которого нужно вернуть.
Возвращает:
Гиперболический синус x.
С версии:
1.5

cosh

public static double cosh(double x)

Возвращает гиперболический косинус значения с плавающей точкой. Гиперболический косинус x определяется как (ex + e-x)/2, где e — число Эйлера.

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен бесконечности, то результат равен положительной бесконечности.
  • Если аргумент равен нулю, то результат равен 1.0.

Вычисленный результат должен находиться в пределах 2.5 ulps от точного результата.

Параметры:
x — число, гиперболический косинус которого нужно вернуть.
Возвращает:
Гиперболический косинус x.
С версии:
1.5

tanh

public static double tanh(double x)

Возвращает гиперболическую тангенс значения с плавающей точкой. Гиперболическая тангенс x определяется как (ex - e-x)/(ex + e-x), другими словами, sinh(x)/cosh(x). Обратите внимание, что абсолютное значение точного tanh всегда меньше 1.

Особые случаи:

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен нулю, то результат — ноль с тем же знаком, что и аргумент.
  • Если аргумент равен положительной бесконечности, то результат равен +1.0.
  • Если аргумент равен отрицательной бесконечности, то результат равен -1.0.

Вычисленный результат должен находиться в пределах 2.5 ulps от точного результата. Результат tanh для любого конечного входного значения должен иметь абсолютное значение меньше или равно 1. Обратите внимание, что, как только точный результат tanh находится в пределах 1/2 ulp от предельного значения ±1, следует вернуть правильно обозначенные ±1.0.

Параметры:
x — число, гиперболическую тангенс которого нужно вернуть.
Возвращает:
Гиперболическая тангенс x.
С версии:
1.5

hypot

public static double hypot(double x,
                           double y)

Возвращает sqrt(x2 +y2) без промежуточного переполнения или потери точности.

Особые случаи:

  • Если любой из аргументов бесконечен, результат — положительная бесконечность.
  • Если любой из аргументов — NaN, а ни один из аргументов не бесконечен, результат — NaN.

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

Параметры:
x - значение
y - значение
Возвращает:
sqrt(x2 +y2) без промежуточного переполнения или потери точности
С:
1.5

expm1

public static double expm1(double x)

Возвращает ex -1. Обратите внимание, что для значений x, близких к 0, точная сумма expm1(x) + 1 намного ближе к истинному результату ex, чем exp(x).

Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — отрицательная бесконечность, результат — -1.0.
  • Если аргумент — ноль, результат — ноль с тем же знаком, что и аргумент.

Вычисленный результат должен отличаться от точного результата не более чем на 1 единицу в последнем разряде. Результаты должны быть полумонотонными. Результат expm1 для любого конечного входного значения должен быть больше или равен -1.0. Обратите внимание, что как только точный результат ex - 1 окажется в пределах 1/2 единицы в последнем разряде от предельного значения -1, должно быть возвращено -1.0.

Параметры:
x - показатель степени, к которой необходимо возвести e при вычислении ex -1.
Возвращает:
значение ex - 1.
С:
1.5

log1p

public static double log1p(double x)

Возвращает натуральный логарифм суммы аргумента и 1. Обратите внимание, что для малых значений x, результат log1p(x) намного ближе к истинному результату ln(1 + x) по сравнению с плавающей точкой log(1.0+x).

Особые случаи:

  • Если аргумент — NaN или меньше -1, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — минус один, результат — минус бесконечность.
  • Если аргумент — ноль, результат — ноль с тем же знаком, что и аргумент.

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

Параметры:
x - значение
Возвращает:
значение ln(x + 1), натуральный логарифм x + 1
С:
1.5

copySign

public static double copySign(double magnitude,
                              double sign)

Возвращает первый аргумент с плавающей точкой со знаком второго аргумента с плавающей точкой. Обратите внимание, что в отличие от метода StrictMath.copySign, данному методу не требуется, чтобы NaN sign аргументы обрабатывались как положительные значения; реализация может обрабатывать некоторые NaN аргументы как положительные, а другие как отрицательные для повышения производительности.

Параметры:
magnitude - параметр, определяющий величину результата
sign - параметр, определяющий знак результата
Возвращает:
значение с величиной magnitude и знаком sign.
С:
1.6

copySign

public static float copySign(float magnitude,
                             float sign)

Возвращает первый аргумент с плавающей точкой со знаком второго аргумента с плавающей точкой. Обратите внимание, что в отличие от метода StrictMath.copySign, данному методу не требуется, чтобы NaN sign аргументы обрабатывались как положительные значения; реализация может обрабатывать некоторые NaN аргументы как положительные, а другие как отрицательные для повышения производительности.

Параметры:
magnitude - параметр, определяющий величину результата
sign - параметр, определяющий знак результата
Возвращает:
значение с величиной magnitude и знаком sign.
С:
1.6

getExponent

public static int getExponent(float f)

Возвращает несмещённый показатель степени, используемый в представлении float. Особые случаи:

  • Если аргумент — NaN или бесконечность, результат — Float.MAX_EXPONENT + 1.
  • Если аргумент — ноль или число с пониженной точностью, результат — Float.MIN_EXPONENT -1.

Параметры:
f - значение с плавающей точкой
Возвращает:
несмещённый показатель степени аргумента
С:
1.6

getExponent

public static int getExponent(double d)

Возвращает несмещённый показатель степени, используемый в представлении double. Особые случаи:

  • Если аргумент — NaN или бесконечность, результат — Double.MAX_EXPONENT + 1.
  • Если аргумент — ноль или число с пониженной точностью, результат — Double.MIN_EXPONENT -1.

Параметры:
d - значение с плавающей точкой
Возвращает:
несмещённый показатель степени аргумента
С:
1.6

nextAfter

public static double nextAfter(double start,
                               double direction)

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

Особые случаи:

  • Если любой из аргументов — NaN, возвращается NaN.
  • Если оба аргумента — знаковые нули, возвращается direction (как подразумевается требованием возвращать второй аргумент, если аргументы равны).
  • Если start равно ±Double.MIN_VALUE и direction имеет такое значение, что результат должен иметь меньшую величину, возвращается ноль с тем же знаком, что и start.
  • Если start бесконечно и direction имеет такое значение, что результат должен иметь меньшую величину, возвращается Double.MAX_VALUE с тем же знаком, что и start.
  • Если start равно ± Double.MAX_VALUE и direction имеет такое значение, что результат должен иметь большую величину, возвращается бесконечность с тем же знаком, что и start.
Параметры:
start - начальное значение с плавающей точкой
direction - значение, указывающее, какой из соседей start или start следует вернуть
Возвращает:
Число с плавающей точкой, соседнее с start в направлении direction.
С:
1.6

nextAfter

public static float nextAfter(float start,
                              double direction)

Возвращает число с плавающей точкой, соседнее с первым аргументом в направлении второго аргумента. Если оба аргумента равны, возвращается значение, эквивалентное второму аргументу.

Особые случаи:

  • Если любой из аргументов — NaN, возвращается NaN.
  • Если оба аргумента — знаковые нули, возвращается значение, эквивалентное direction.
  • Если start равно ±Float.MIN_VALUE и direction имеет такое значение, что результат должен иметь меньшую величину, возвращается ноль с тем же знаком, что и start.
  • Если start бесконечно и direction имеет такое значение, что результат должен иметь меньшую величину, возвращается Float.MAX_VALUE с тем же знаком, что и start.
  • Если start равно ± Float.MAX_VALUE и direction имеет такое значение, что результат должен иметь большую величину, возвращается бесконечность с тем же знаком, что и start.
Параметры:
start - начальное значение с плавающей точкой
direction - значение, указывающее, какой из соседей start или start следует вернуть
Возвращает:
Число с плавающей точкой, соседнее с start в направлении direction.
С:
1.6

nextUp

public static double nextUp(double d)

Возвращает значение с плавающей точкой, соседнее с d в направлении положительной бесконечности. Этот метод семантически эквивалентен nextAfter(d, Double.POSITIVE_INFINITY); однако, реализация nextUp может работать быстрее, чем эквивалентный вызов nextAfter.

Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — ноль, результат — Double.MIN_VALUE
Параметры:
d - начальное значение с плавающей точкой
Возвращает:
Соседнее значение с плавающей точкой, более близкое к положительной бесконечности.
С:
1.6

nextUp

public static float nextUp(float f)

Возвращает значение с плавающей точкой, соседнее с f в направлении положительной бесконечности. Этот метод семантически эквивалентен nextAfter(f, Float.POSITIVE_INFINITY); однако, реализация nextUp может работать быстрее, чем эквивалентный вызов nextAfter.

Особые случаи:

  • Если аргумент — NaN, результат — NaN.
  • Если аргумент — положительная бесконечность, результат — положительная бесконечность.
  • Если аргумент — ноль, результат — Float.MIN_VALUE
Параметры:
f - начальное значение с плавающей точкой
Возвращает:
Соседнее значение с плавающей точкой, более близкое к положительной бесконечности.
С:
1.6

nextDown

public static double nextDown(double d)

Возвращает значение с плавающей запятой, смежное с d в направлении отрицательной бесконечности. Этот метод семантически эквивалентен nextAfter(d, Double.NEGATIVE_INFINITY); однако, реализация nextDown может выполняться быстрее, чем эквивалентный вызов nextAfter.

Особые случаи:

  • Если аргумент является NaN, результатом является NaN.
  • Если аргумент является отрицательной бесконечностью, результатом является отрицательная бесконечность.
  • Если аргумент равен нулю, результатом является -Double.MIN_VALUE
Параметры:
d - начальное значение с плавающей запятой
Возвращает:
Смежное значение с плавающей запятой, более близкое к отрицательной бесконечности.
С:
1.8

nextDown

public static float nextDown(float f)

Возвращает значение с плавающей запятой, смежное с f в направлении отрицательной бесконечности. Этот метод семантически эквивалентен nextAfter(f, Float.NEGATIVE_INFINITY); однако, реализация nextDown может выполняться быстрее, чем эквивалентный вызов nextAfter.

Особые случаи:

  • Если аргумент является NaN, результатом является NaN.
  • Если аргумент является отрицательной бесконечностью, результатом является отрицательная бесконечность.
  • Если аргумент равен нулю, результатом является -Float.MIN_VALUE
Параметры:
f - начальное значение с плавающей запятой
Возвращает:
Смежное значение с плавающей запятой, более близкое к отрицательной бесконечности.
С:
1.8

scalb

public static double scalb(double d,
                           int scaleFactor)

Возвращает d × 2scaleFactor, округлённое так, как если бы оно было выполнено одним правильным округлением с плавающей запятой до значения типа double. См. спецификацию языка Java для обсуждения наборов значений с плавающей запятой. Если показатель степени результата находится между Double.MIN_EXPONENT и Double.MAX_EXPONENT, ответ вычисляется точно. Если показатель степени результата будет больше Double.MAX_EXPONENT, возвращается бесконечность. Обратите внимание, что если результат является субнормальным, то точность может быть потеряна; то есть, когда scalb(x, n) является субнормальным, scalb(scalb(x, n), -n) может не быть равно x. Когда результат не NaN, результат имеет тот же знак, что и d.

Особые случаи:

  • Если первый аргумент является NaN, возвращается NaN.
  • Если первый аргумент является бесконечностью, возвращается бесконечность того же знака.
  • Если первый аргумент равен нулю, возвращается ноль того же знака.
Параметры:
d - число, которое необходимо масштабировать с помощью степени двойки.
scaleFactor - степень двойки, используемая для масштабирования d
Возвращает:
d × 2scaleFactor
С:
1.6

scalb

public static float scalb(float f,
                          int scaleFactor)

Возвращает f × 2scaleFactor, округлённое так, как если бы оно было выполнено одним правильным округлением с плавающей запятой до значения типа float. См. спецификацию языка Java для обсуждения наборов значений с плавающей запятой. Если показатель степени результата находится между Float.MIN_EXPONENT и Float.MAX_EXPONENT, ответ вычисляется точно. Если показатель степени результата будет больше Float.MAX_EXPONENT, возвращается бесконечность. Обратите внимание, что если результат является субнормальным, то точность может быть потеряна; то есть, когда scalb(x, n) является субнормальным, scalb(scalb(x, n), -n) может не быть равно x. Когда результат не NaN, результат имеет тот же знак, что и f.

Особые случаи:

  • Если первый аргумент является NaN, возвращается NaN.
  • Если первый аргумент является бесконечностью, возвращается бесконечность того же знака.
  • Если первый аргумент равен нулю, возвращается ноль того же знака.
Параметры:
f - число, которое необходимо масштабировать с помощью степени двойки.
scaleFactor - степень двойки, используемая для масштабирования f
Возвращает:
f × 2scaleFactor
С:
1.6

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html

Spec-Zone .ru
спецификации, руководства, описания, API