Класс Math

java.lang.Object

java.lang.Math

public final class Math extends Object

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

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

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

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

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

Краткое описание полей

Модификатор и тип	Поле	Описание
`static final double`	`E`	Значение `double`, которое ближе любого другого к e — основанию натуральных логарифмов.
`static final double`	`PI`	Значение `double`, которое ближе любого другого к pi (π) — отношению длины окружности к её диаметру.
`static final double`	`TAU`	Значение `double`, которое ближе любого другого к tau (τ) — отношению длины окружности к её радиусу.

Краткое описание методов

Модификатор и тип	Метод	Описание
`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 int`	`absExact(int a)`	Возвращает математическое абсолютное значение значения типа `int`, если оно точно представимо как `int`; если результат выходит за пределы положительного диапазона `int`, выбрасывает `ArithmeticException`.
`static long`	`absExact(long a)`	Возвращает математическое абсолютное значение значения типа `long`, если оно точно представимо как `long`; если результат выходит за пределы положительного диапазона `long`, выбрасывает `ArithmeticException`.
`static double`	`acos(double a)`	Возвращает арккосинус значения; возвращаемый угол находится в диапазоне от 0.0 до pi.
`static double`	`acosh(double x)`	Возвращает обратный гиперболический косинус значения типа `double`.
`static int`	`addExact(int x, int y)`	Возвращает сумму аргументов; если результат переполняет `int`, выбрасывает исключение.
`static long`	`addExact(long x, long y)`	Возвращает сумму аргументов; если результат переполняет `long`, выбрасывает исключение.
`static double`	`asin(double a)`	Возвращает арксинус значения; возвращаемый угол находится в диапазоне от −pi/2 до pi/2.
`static double`	`asinh(double x)`	Возвращает обратный гиперболический синус значения типа `double`.
`static double`	`atan(double a)`	Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от −pi/2 до pi/2.
`static double`	`atan2(double y, double x)`	Возвращает угол theta при преобразовании прямоугольных координат (`x`, `y`) в полярные координаты (r, theta).
`static double`	`atanh(double x)`	Возвращает обратный гиперболический тангенс значения типа `double`.
`static double`	`cbrt(double a)`	Возвращает кубический корень значения типа `double`.
`static double`	`ceil(double a)`	Возвращает наименьшее значение типа `double` (ближайшее к минус бесконечности), которое больше или равно аргументу и является математическим целым числом.
`static int`	`ceilDiv(int x, int y)`	Возвращает наименьшее значение типа `int` (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.
`static long`	`ceilDiv(long x, int y)`	Возвращает наименьшее значение типа `long` (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.
`static long`	`ceilDiv(long x, long y)`	Возвращает наименьшее значение типа `long` (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.
`static int`	`ceilDivExact(int x, int y)`	Возвращает наименьшее значение типа `int` (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.
`static long`	`ceilDivExact(long x, long y)`	Возвращает наименьшее значение типа `long` (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.
`static int`	`ceilMod(int x, int y)`	Возвращает остаток от деления с округлением вверх для аргументов типа `int`.
`static int`	`ceilMod(long x, int y)`	Возвращает остаток от деления с округлением вверх для аргументов типа `long` и `int`.
`static long`	`ceilMod(long x, long y)`	Возвращает остаток от деления с округлением вверх для аргументов типа `long`.
`static double`	`clamp(double value, double min, double max)`	Ограничивает значение диапазоном от min до max.
`static float`	`clamp(float value, float min, float max)`	Ограничивает значение диапазоном от min до max.
`static int`	`clamp(long value, int min, int max)`	Ограничивает значение диапазоном от min до max.
`static long`	`clamp(long value, long min, long max)`	Ограничивает значение диапазоном от min до max.
`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 int`	`divideExact(int x, int y)`	Возвращает частное аргументов; если результат переполняет `int`, выбрасывает исключение.
`static long`	`divideExact(long x, long y)`	Возвращает частное аргументов; если результат переполняет `long`, выбрасывает исключение.
`static double`	`exp(double a)`	Возвращает число Эйлера e в степени значения типа `double`.
`static double`	`expm1(double x)`	Возвращает e^x −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`	`floorDivExact(int x, int y)`	Возвращает наибольшее значение типа `int` (ближайшее к плюс бесконечности), которое меньше или равно алгебраическому частному.
`static long`	`floorDivExact(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(x² +y²) без промежуточного переполнения или потери значимости.
`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)`	Возвращает десятичный логарифм значения типа `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 int`	`powExact(int x, int n)`	Возвращает `x` в степени `n`; если результат переполняет `int`, выбрасывает исключение.
`static long`	`powExact(long x, int n)`	Возвращает `x` в степени `n`; если результат переполняет `long`, выбрасывает исключение.
`static double`	`random()`	Возвращает значение типа `double` с положительным знаком, большее или равное `0.0` и меньшее `1.0`.
`static double`	`rint(double a)`	Возвращает значение типа `double`, наиболее близкое к аргументу и являющееся математическим целым числом.
`static long`	`round(double a)`	Возвращает значение типа `long`, ближайшее к аргументу; при равном удалении округляет в сторону плюс бесконечности.
`static int`	`round(float a)`	Возвращает значение типа `int`, ближайшее к аргументу; при равном удалении округляет в сторону плюс бесконечности.
`static double`	`scalb(double d, int scaleFactor)`	Возвращает `d` × 2^scaleFactor, округлённое так, как если бы вычисление выполнялось одним умножением с плавающей точкой и корректным округлением.
`static float`	`scalb(float f, int scaleFactor)`	Возвращает `f` × 2^scaleFactor, округлённое так, как если бы вычисление выполнялось одним умножением с плавающей точкой и корректным округлением.
`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 аргумента.
`static int`	`unsignedMultiplyExact(int x, int y)`	Возвращает произведение аргументов без знака; если результат переполняет беззнаковое значение типа `int`, выбрасывает исключение.
`static long`	`unsignedMultiplyExact(long x, int y)`	Возвращает произведение аргументов без знака; если результат переполняет беззнаковое значение типа `long`, выбрасывает исключение.
`static long`	`unsignedMultiplyExact(long x, long y)`	Возвращает произведение аргументов без знака; если результат переполняет беззнаковое значение типа `long`, выбрасывает исключение.
`static long`	`unsignedMultiplyHigh(long x, long y)`	Возвращает в виде `long` старшие 64 бита беззнакового 128-битного произведения двух беззнаковых 64-битных множителей.
`static int`	`unsignedPowExact(int x, int n)`	Возвращает беззнаковое `x` в степени `n`; если результат переполняет беззнаковое значение типа `int`, выбрасывает исключение.
`static long`	`unsignedPowExact(long x, int n)`	Возвращает беззнаковое `x` в степени `n`; если результат переполняет беззнаковое значение типа `long`, выбрасывает исключение.

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

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

Модификатор и тип	Метод	Описание
`protected Object`	`clone()`	Создаёт и возвращает копию этого объекта.
`boolean`	`equals(Object obj)`	Показывает, равен ли другой объект этому объекту.
`protected void`	`finalize()`	Устарело, планируется удаление: этот элемент API может быть удалён в будущей версии. Финализация устарела и может быть удалена в одном из следующих выпусков.
`final Class<?>`	`getClass()`	Возвращает класс времени выполнения этого `Object`.
`int`	`hashCode()`	Возвращает хеш-код этого объекта.
`final void`	`notify()`	Пробуждает один поток, ожидающий на мониторе этого объекта.
`final void`	`notifyAll()`	Пробуждает все потоки, ожидающие на мониторе этого объекта.
`String`	`toString()`	Возвращает строковое представление объекта.
`final void`	`wait()`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt.
`final void`	`wait(long timeoutMillis)`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения заданного промежутка реального времени.
`final void`	`wait(long timeoutMillis, int nanos)`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения заданного промежутка реального времени.

Подробное описание полей

E

public static final double E

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

См. также:

PI

public static final double PI

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

См. также:

TAU

public static final double TAU

Значение double, которое ближе любого другого к tau (τ) — отношению длины окружности к её радиусу.

Примечание к API:

Значение pi вдвое меньше значения tau; иными словами, tau вдвое больше pi .

С версии:

См. также:

Подробное описание методов

sin

public static double sin(double a)

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

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

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

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

cos

public static double cos(double a)

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

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

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

tan

public static double tan(double a)

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

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

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

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

asin

public static double asin(double a)

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

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

Параметры:: a — значение, арксинус которого нужно вернуть.
Возвращает:: арксинус аргумента.

acos

public static double acos(double a)

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

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

Параметры:: a — значение, арккосинус которого нужно вернуть.
Возвращает:: арккосинус аргумента.

atan

public static double atan(double a)

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

Если аргумент равен NaN, результат равен NaN.
Если аргумент равен нулю, результатом будет ноль с тем же знаком, что и у аргумента.
Если аргумент бесконечен, результатом будет ближайшее к pi/2 значение с тем же знаком, что и у входного значения.

Параметры:: 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.0.

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

log

public static double log(double a)

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

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

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

log10

public static double log10(double a)

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

Если аргумент равен NaN или меньше нуля, результат равен NaN.
Если аргумент равен положительной бесконечности, результат равен положительной бесконечности.
Если аргумент равен положительному или отрицательному нулю, результат равен отрицательной бесконечности.
Если аргумент равен 10ⁿ для целого числа n, результат равен n. В частности, если аргумент равен 1.0 (10⁰), результат равен положительному нулю.

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

sqrt

public static double sqrt(double a)

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

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

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

Примечание к API:: Этот метод соответствует операции squareRoot, определённой в IEEE 754.
Параметры:: 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).

Примечание к API:: Этот метод соответствует операции roundToIntegralTowardPositive, определённой в IEEE 754.
Параметры:: a — значение.
Возвращает:: наименьшее (ближайшее к отрицательной бесконечности) значение с плавающей точкой, которое больше или равно аргументу и равно математическому целому числу.

floor

public static double floor(double a)

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

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

Примечание к API:: Этот метод соответствует операции roundToIntegralTowardNegative, определённой в IEEE 754.
Параметры:: a — значение.
Возвращает:: наибольшее (ближайшее к положительной бесконечности) значение с плавающей точкой, которое меньше или равно аргументу и равно математическому целому числу.

rint

public static double rint(double a)

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

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

Примечание к API:: Этот метод соответствует операции roundToIntegralTiesToEven, определённой в IEEE 754.
Параметры:: a — значение double.
Возвращает:: ближайшее к a значение с плавающей точкой, равное математическому целому числу.

atan2

public static double atan2(double y, double x)

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

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

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

Примечание к API:

Для y с положительным знаком и конечного ненулевого x точное математическое значение atan2 равно:

если x > 0, atan(abs(y/x))
если x < 0, π - atan(abs(y/x))

Параметры:

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.
Если оба аргумента являются целыми числами, результат в точности равен математическому результату возведения первого аргумента в степень второго, если этот результат можно точно представить как значение double.

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

Примечание к API:: Определения особых случаев этого метода отличаются от определений особых случаев рекомендуемой IEEE 754 операции pow для возведения ±1.0 в бесконечную степень. Этот метод считает такие случаи неопределёнными и предписывает возвращать NaN. Спецификация IEEE 754 трактует бесконечную степень как большое целое число (числа с плавающей точкой большого модуля являются целыми, в частности чётными) и поэтому предписывает возвращать 1.0.
Параметры:: a — основание.; b — показатель степени.
Возвращает:: значение a^b.

round

public static int round(float a)

Возвращает ближайшее int к аргументу; при равном расстоянии округляет в сторону положительной бесконечности.

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

Если аргумент равен NaN, результат равен 0.
Если аргумент равен отрицательной бесконечности или меньше либо равен значению Integer.MIN_VALUE, результат равен значению Integer.MIN_VALUE.
Если аргумент равен положительной бесконечности или больше либо равен значению Integer.MAX_VALUE, результат равен значению Integer.MAX_VALUE.

Параметры:

a — значение с плавающей точкой, которое нужно округлить до целого числа.

Возвращает:

значение аргумента, округлённое до ближайшего значения int.

См. также:

round

public static long round(double a)

Возвращает ближайшее long к аргументу; при равном расстоянии округляет в сторону положительной бесконечности.

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

Если аргумент равен NaN, результат равен 0.
Если аргумент равен отрицательной бесконечности или меньше либо равен значению Long.MIN_VALUE, результат равен значению Long.MIN_VALUE.
Если аргумент равен положительной бесконечности или больше либо равен значению Long.MAX_VALUE, результат равен значению Long.MAX_VALUE.

Параметры:

a — значение с плавающей точкой, которое нужно округлить до long.

Возвращает:

значение аргумента, округлённое до ближайшего значения long.

См. также:

random

public static double random()

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

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

new java.util.Random()

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

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

Примечание к API:

Поскольку наибольшее значение double, меньшее 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;

Возвращает:

псевдослучайное значение double, большее или равное 0.0 и меньшее 1.0.

См. также:

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

divideExact

public static int divideExact(int x, int y)

Возвращает частное аргументов, выбрасывая исключение, если результат выходит за пределы типа int. В этом методе такое переполнение происходит, если x равно Integer.MIN_VALUE, а y равно -1. В отличие от этого, если бы Integer.MIN_VALUE / -1 вычислялось напрямую, результатом было бы Integer.MIN_VALUE, и исключение не выбрасывалось бы.

Если y равно нулю, выбрасывается ArithmeticException (JLS Â§15.17.2).

Встроенный оператор остатка от деления «%» является подходящим дополнением как к этому методу, так и к встроенному оператору деления «/».

Параметры:: x — делимое; y — делитель
Возвращает:: частное x / y
Выбрасывает:: ArithmeticException — если y равно нулю или частное выходит за пределы типа int
См. Спецификацию языка Java:: 15.17.2 Оператор деления /
Начиная с версии:: 18

divideExact

public static long divideExact(long x, long y)

Возвращает частное аргументов, выбрасывая исключение, если результат выходит за пределы типа long. В этом методе такое переполнение происходит, если x равно Long.MIN_VALUE, а y равно -1. В отличие от этого, если бы Long.MIN_VALUE / -1 вычислялось напрямую, результатом было бы Long.MIN_VALUE, и исключение не выбрасывалось бы.

Если y равно нулю, выбрасывается ArithmeticException (JLS Â§15.17.2).

Параметры:: x — делимое; y — делитель
Возвращает:: частное x / y
Выбрасывает:: ArithmeticException — если y равно нулю или частное выходит за пределы типа long
См. Спецификацию языка Java:: 15.17.2 Оператор деления /
Начиная с версии:: 18

floorDivExact

public static int floorDivExact(int x, int y)

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

Метод вычисления остатка по модулю с округлением вниз floorMod(int,int) является подходящим дополнением как к этому методу, так и к методу floorDiv(int,int).

Примеры см. в описании floorDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наибольшее значение int (ближайшее к плюс бесконечности), которое меньше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю либо делимое x равно Integer.MIN_VALUE, а делитель y равен -1.

Начиная с версии:

См. также:

floorDivExact

public static long floorDivExact(long x, long y)

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

Метод вычисления остатка по модулю с округлением вниз floorMod(long,long) является подходящим дополнением как к этому методу, так и к методу floorDiv(long,long).

Примеры см. в описании floorDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наибольшее значение long (ближайшее к плюс бесконечности), которое меньше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю либо делимое x равно Long.MIN_VALUE, а делитель y равен -1.

Начиная с версии:

См. также:

ceilDivExact

public static int ceilDivExact(int x, int y)

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

Метод вычисления остатка по модулю с округлением вверх ceilMod(int,int) является подходящим дополнением как к этому методу, так и к методу ceilDiv(int,int).

Примеры см. в описании ceilDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наименьшее значение int (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю либо делимое x равно Integer.MIN_VALUE, а делитель y равен -1.

Начиная с версии:

См. также:

ceilDivExact

public static long ceilDivExact(long x, long y)

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

Метод вычисления остатка по модулю с округлением вверх ceilMod(long,long) является подходящим дополнением как к этому методу, так и к методу ceilDiv(long,long).

Примеры см. в описании ceilDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наименьшее значение long (ближайшее к минус бесконечности), которое больше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю либо делимое x равно Long.MIN_VALUE, а делитель y равен -1.

Начиная с версии:

См. также:

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 — второе значение

Возвращает:

результат

Начиная с версии:

См. также:

unsignedMultiplyHigh

public static long unsignedMultiplyHigh(long x, long y)

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

Параметры:

x — первое значение

y — второе значение

Возвращает:

результат

Начиная с версии:

См. также:

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

См. также:

floorDiv

public static long floorDiv(long x, int y)

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

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

Примеры см. в описании floorDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наибольшее значение long (ближайшее к плюс бесконечности), которое меньше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

См. также:

floorDiv

public static long floorDiv(long x, long y)

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

Примеры см. в описании floorDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наибольшее значение long (ближайшее к плюс бесконечности), которое меньше или равно алгебраическому частному.

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

1.8

См. также:

floorMod

public static int floorMod(int x, int y)

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

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

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

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

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

Примеры:

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

Параметры:

x — делимое

y — делитель

Возвращает:

остаток от деления по модулю с округлением вниз x - (floorDiv(x, y) * y)

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

1.8

См. также:

floorMod

public static int floorMod(long x, int y)

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

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

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

Примеры см. в описании floorMod(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

остаток от деления по модулю с округлением вниз x - (floorDiv(x, y) * y)

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

См. также:

floorMod

public static long floorMod(long x, long y)

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

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

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

Примеры см. в описании floorMod(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

остаток от деления по модулю с округлением вниз x - (floorDiv(x, y) * y)

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

1.8

См. также:

ceilDiv

public static int ceilDiv(int x, int y)

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

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

Если знаки аргументов различаются, результаты ceilDiv и оператора / одинаковы.
Например, ceilDiv(-4, 3) == -1 и (-4 / 3) == -1.
Если знаки аргументов совпадают, ceilDiv возвращает наименьшее целое число, большее или равное частному, а оператор / возвращает наибольшее целое число, меньшее или равное частному. Результаты различаются тогда и только тогда, когда частное не является целым числом.
Например, ceilDiv(4, 3) == 2, тогда как (4 / 3) == 1.

Параметры:

x — делимое

y — делитель

Возвращает:

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

См. также:

ceilDiv

public static long ceilDiv(long x, int y)

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

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

Примеры см. в описании ceilDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

Выбрасывает:

ArithmeticException — если делитель y равен нулю

Начиная с версии:

См. также:

ceilDiv

public static long ceilDiv(long x, long y)

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

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

Примеры см. в разделе ceilDiv(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

наименьшее (ближайшее к отрицательной бесконечности) значение long, которое больше или равно алгебраическому частному.

Вызывает исключение:

ArithmeticException — если делитель y равен нулю

С версии:

См. также:

ceilMod

public static int ceilMod(int x, int y)

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

Модуль округления вверх — это r = x - (ceilDiv(x, y) * y); он имеет знак, противоположный знаку делителя y, или равен нулю и находится в диапазоне -abs(y) < r < +abs(y).

Соотношение между ceilDiv и ceilMod таково:

ceilDiv(x, y) * y + ceilMod(x, y) == x

Различие значений между ceilMod и оператором % обусловлено различием между ceilDiv и оператором /, как подробно описано в разделе ceilDiv(int, int).

Примеры:

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

Параметры:

x — делимое

y — делитель

Возвращает:

модуль округления вверх x - (ceilDiv(x, y) * y)

Вызывает исключение:

ArithmeticException — если делитель y равен нулю

С версии:

См. также:

ceilMod

public static int ceilMod(long x, int y)

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

Соотношение между ceilDiv и ceilMod таково:

ceilDiv(x, y) * y + ceilMod(x, y) == x

Примеры см. в разделе ceilMod(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

модуль округления вверх x - (ceilDiv(x, y) * y)

Вызывает исключение:

ArithmeticException — если делитель y равен нулю

С версии:

См. также:

ceilMod

public static long ceilMod(long x, long y)

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

Соотношение между ceilDiv и ceilMod таково:

ceilDiv(x, y) * y + ceilMod(x, y) == x

Примеры см. в разделе ceilMod(int, int).

Параметры:

x — делимое

y — делитель

Возвращает:

модуль округления вверх x - (ceilDiv(x, y) * y)

Вызывает исключение:

ArithmeticException — если делитель y равен нулю

С версии:

См. также:

abs

public static int abs(int a)

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

Обратите внимание: если аргумент равен значению Integer.MIN_VALUE — самому отрицательному представимому значению типа int, результатом будет то же самое отрицательное значение. В отличие от этого, метод absExact(int) для этого значения вызывает исключение ArithmeticException.

Параметры:

a — аргумент, абсолютное значение которого требуется определить

Возвращает:

абсолютное значение аргумента.

См. также:

absExact

public static int absExact(int a)

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

Поскольку диапазон целых чисел в дополнительном коде асимметричен и содержит на одно отрицательное значение больше (JLS Â§4.2.1), математическое абсолютное значение Integer.MIN_VALUE выходит за пределы положительного диапазона int, поэтому для этого аргумента вызывается исключение.

Параметры:

a — аргумент, абсолютное значение которого требуется определить

Возвращает:

абсолютное значение аргумента, если не происходит переполнение

Вызывает исключение:

ArithmeticException — если аргумент равен Integer.MIN_VALUE

С версии:

См. также:

abs

public static long abs(long a)

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

Обратите внимание: если аргумент равен значению Long.MIN_VALUE — самому отрицательному представимому значению типа long, результатом будет то же самое отрицательное значение. В отличие от этого, метод absExact(long) для этого значения вызывает исключение ArithmeticException.

Параметры:

a — аргумент, абсолютное значение которого требуется определить

Возвращает:

абсолютное значение аргумента.

См. также:

absExact

public static long absExact(long a)

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

Поскольку диапазон целых чисел в дополнительном коде асимметричен и содержит на одно отрицательное значение больше (JLS Â§4.2.1), математическое абсолютное значение Long.MIN_VALUE выходит за пределы положительного диапазона long, поэтому для этого аргумента вызывается исключение.

Параметры:

a — аргумент, абсолютное значение которого требуется определить

Возвращает:

абсолютное значение аргумента, если не происходит переполнение

Вызывает исключение:

ArithmeticException — если аргумент равен Long.MIN_VALUE

С версии:

См. также:

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. В отличие от операторов числового сравнения, этот метод считает отрицательный ноль строго меньшим положительного нуля. Если один аргумент — положительный ноль, а другой — отрицательный, результатом будет положительный ноль.

Примечание к API:: Этот метод соответствует операции вычисления максимума, определенной в IEEE 754.
Параметры:: a — аргумент.; b — другой аргумент.
Возвращает:: большее из a и b.

max

public static double max(double a, double b)

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

Примечание к API:: Этот метод соответствует операции вычисления максимума, определенной в IEEE 754.
Параметры:: 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. В отличие от операторов числового сравнения, этот метод считает отрицательный ноль строго меньшим положительного нуля. Если один аргумент — положительный ноль, а другой — отрицательный, результатом будет отрицательный ноль.

Примечание к API:: Этот метод соответствует операции вычисления минимума, определенной в IEEE 754.
Параметры:: a — аргумент.; b — другой аргумент.
Возвращает:: меньшее из a и b.

min

public static double min(double a, double b)

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

Примечание к API:: Этот метод соответствует операции вычисления минимума, определенной в IEEE 754.
Параметры:: a — аргумент.; b — другой аргумент.
Возвращает:: меньшее из a и b.

clamp

public static int clamp(long value, int min, int max)

Ограничивает значение диапазоном от min до max. Если значение меньше min, возвращается min. Если значение больше max, возвращается max. В противном случае возвращается исходное значение.

Хотя исходное значение типа long может не помещаться в тип int, граничные значения имеют тип int, поэтому результат всегда помещается в тип int. Это позволяет безопасно преобразовать значение типа long в int с насыщением с помощью этого метода.

Параметры:: value — ограничиваемое значение; min — минимально допустимое значение; max — максимально допустимое значение
Возвращает:: ограниченное значение, попадающее в интервал min..max
Вызывает исключение:: IllegalArgumentException — если min > max
С версии:: 21

clamp

public static long clamp(long value, long min, long max)

Параметры:: value — ограничиваемое значение; min — минимально допустимое значение; max — максимально допустимое значение
Возвращает:: ограниченное значение, попадающее в интервал min..max
Вызывает исключение:: IllegalArgumentException — если min > max
С версии:: 21

clamp

public static double clamp(double value, double min, double max)

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

Параметры:: value — ограничиваемое значение; min — минимально допустимое значение; max — максимально допустимое значение
Возвращает:: ограниченное значение, попадающее в интервал min..max
Вызывает исключение:: IllegalArgumentException — если один из аргументов min и max равен NaN или min > max, либо если min равен +0.0, а max равен -0.0.
С версии:: 21

clamp

public static float clamp(float value, float min, float max)

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

Параметры:: value — ограничиваемое значение; min — минимально допустимое значение; max — максимально допустимое значение
Возвращает:: ограниченное значение, попадающее в интервал min..max
Вызывает исключение:: IllegalArgumentException — если один из аргументов min и max равен NaN или min > max, либо если min равен +0.0f, а max равен -0.0f.
С версии:: 21

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.
Параметры:: 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.
Параметры:: a — значение; b — значение; c — значение
Возвращает:: (a × b + c) вычисляется как при неограниченных диапазоне и точности и однократно округляется до ближайшего значения float
С версии:: 9

ulp

public static double ulp(double d)

Возвращает размер ulp аргумента. ULP (единица последнего разряда) значения типа double — это положительное расстояние между этим числом с плавающей точкой и следующим по величине значением


double

. Обратите внимание, что для x, не равного NaN, ulp(-x) == ulp(x).

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

Если аргумент равен NaN, результатом будет NaN.
Если аргумент — положительная или отрицательная бесконечность, результатом будет положительная бесконечность.
Если аргумент — положительный или отрицательный ноль, результатом будет Double.MIN_VALUE.
Если аргумент равен ±Double.MAX_VALUE, результат равен 2⁹⁷¹.

Параметры:: d — значение с плавающей точкой, для которого требуется вернуть ulp
Возвращает:: размер ulp аргумента
С версии:: 1.5

ulp

public static float ulp(float f)

Возвращает размер ulp аргумента. ULP (единица последнего разряда) значения типа float — это положительное расстояние между этим числом с плавающей точкой и следующим по величине значением


float

. Обратите внимание, что для x, не равного NaN, ulp(-x) == ulp(x).

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

Если аргумент равен NaN, результатом будет NaN.
Если аргумент — положительная или отрицательная бесконечность, результатом будет положительная бесконечность.
Если аргумент — положительный или отрицательный ноль, результатом будет Float.MIN_VALUE.
Если аргумент равен ±Float.MAX_VALUE, результат равен 2¹⁰⁴.

Параметры:: 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)

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

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

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

Вычисленный результат должен отличаться от точного не более чем на 2,5 ULP.

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

cosh

public static double cosh(double x)

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

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

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

Вычисленный результат должен отличаться от точного не более чем на 2,5 ULP.

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

tanh

public static double tanh(double x)

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

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

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

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

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

asinh

public static double asinh(double x)

Возвращает обратный гиперболический синус значения типа double. Обратный гиперболический синус x определяется как функция, для которой asinh(sinh(x)) = x для любого x. Обратите внимание, что область определения и область значений точной функции asinh не ограничены.

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

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

Вычисленный результат должен отличаться от точного не более чем на 2,5 ULP.

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

acosh

public static double acosh(double x)

Возвращает обратный гиперболический косинус значения типа double. Обратный гиперболический косинус x определяется как функция, для которой acosh(cosh(x)) = x при любом x >= 0. Обратите внимание, что область значений точной функции acosh(x) — >= 0.

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

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

Вычисленный результат должен отличаться от точного не более чем на 2,5 ULP.

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

atanh

public static double atanh(double x)

Возвращает обратный гиперболический тангенс значения типа double. Обратный гиперболический тангенс x определяется как функция, для которой atanh(tanh(x)) = x для любого x. Обратите внимание, что область определения точной функции atanh — (-1; 1), а область значений не ограничена.

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

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

Вычисленный результат должен отличаться от точного не более чем на 2,5 ULP.

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

hypot

public static double hypot(double x, double y)

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

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

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

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

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

expm1

public static double expm1(double x)

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

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

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

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

Параметры:: x — показатель степени, в которую возводится e при вычислении e^x −1.
Возвращает:: значение e^x - 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 ULP. Результаты должны быть полумонотонными.

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

copySign

public static double copySign(double magnitude, double sign)

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

Примечание к API:: Этот метод соответствует операции copySign, определенной в IEEE 754.
Параметры:: magnitude — параметр, задающий модуль результата; sign — параметр, задающий знак результата
Возвращает:: значение с модулем magnitude и знаком sign.
С версии:: 1.6

copySign

public static float copySign(float magnitude, float sign)

Примечание к API:: Этот метод соответствует операции copySign, определенной в IEEE 754.
Параметры:: magnitude — параметр, задающий модуль результата; sign — параметр, задающий знак результата
Возвращает:: значение с модулем magnitude и знаком sign.
С версии:: 1.6

getExponent

public static int getExponent(float f)

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

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

Примечание к API:: Этот метод аналогичен операции logB, определенной в IEEE 754, но возвращает другое значение для субнормальных аргументов.
Параметры:: f — значение типа float
Возвращает:: несмещенную экспоненту аргумента
С версии:: 1.6

getExponent

public static int getExponent(double d)

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

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

Примечание к API:: Этот метод аналогичен операции logB, определенной в IEEE 754, но возвращает другое значение для субнормальных аргументов.
Параметры:: d — значение типа double
Возвращает:: несмещенную экспоненту аргумента
С версии:: 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.

Примечание к API:: Этот метод соответствует операции nextUp, определенной в IEEE 754.
Параметры:: d — начальное значение с плавающей точкой
Возвращает:: Соседнее значение с плавающей точкой, более близкое к положительной бесконечности.
С версии:: 1.6

nextUp

public static float nextUp(float f)

Возвращает значение с плавающей точкой, соседнее с f в направлении положительной бесконечности. Этот метод семантически эквивалентен

nextAfter(f,
Float.POSITIVE_INFINITY)

; однако реализация nextUp может работать быстрее, чем эквивалентный вызов nextAfter.

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

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

Примечание к API:: Этот метод соответствует операции nextUp, определенной в IEEE 754.
Параметры:: f — начальное значение с плавающей точкой
Возвращает:: Соседнее значение с плавающей точкой, более близкое к положительной бесконечности.
С версии:: 1.6

nextDown

public static double nextDown(double d)

Возвращает значение с плавающей точкой, соседнее с d в направлении отрицательной бесконечности. Этот метод семантически эквивалентен

nextAfter(d,
Double.NEGATIVE_INFINITY)

; однако реализация nextDown может работать быстрее, чем эквивалентный вызов nextAfter.

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

Если аргумент — NaN, результат равен NaN.
Если аргумент — отрицательная бесконечность, результатом будет отрицательная бесконечность.
Если аргумент равен нулю, результат равен -Double.MIN_VALUE.

Примечание к API:: Этот метод соответствует операции nextDown, определенной в IEEE 754.
Параметры:: d — начальное значение с плавающей точкой
Возвращает:: Соседнее значение с плавающей точкой, более близкое к отрицательной бесконечности.
С версии:: 1.8

nextDown

public static float nextDown(float f)

Возвращает значение с плавающей точкой, соседнее с f в направлении отрицательной бесконечности. Этот метод семантически эквивалентен

nextAfter(f,
Float.NEGATIVE_INFINITY)

; однако реализация nextDown может работать быстрее, чем эквивалентный вызов nextAfter.

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

Если аргумент — NaN, результат равен NaN.
Если аргумент — отрицательная бесконечность, результатом будет отрицательная бесконечность.
Если аргумент равен нулю, результат равен -Float.MIN_VALUE.

Примечание к API:: Этот метод соответствует операции nextDown, определенной в IEEE 754.
Параметры:: f — начальное значение с плавающей точкой
Возвращает:: Соседнее значение с плавающей точкой, более близкое к отрицательной бесконечности.
С версии:: 1.8

scalb

public static double scalb(double d, int scaleFactor)

Возвращает d × 2^scaleFactor, округленное так, как если бы вычисление выполнялось одним умножением чисел с плавающей точкой с корректным округлением. Если экспонента результата находится в диапазоне от Double.MIN_EXPONENT до Double.MAX_EXPONENT, ответ вычисляется точно. Если экспонента результата превышала бы


Double.MAX_EXPONENT

, возвращается бесконечность. Обратите внимание, что если результат субнормальный, точность может быть потеряна; то есть, когда scalb(x, n) является субнормальным,

scalb(scalb(x, n),
-n)

может не равняться x. Если результат не является NaN, он имеет тот же знак, что и d.

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

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

Примечание к API:: Этот метод соответствует операции scaleB, определенной в IEEE 754.
Параметры:: d — число, которое требуется масштабировать степенью двойки.; scaleFactor — степень числа 2, используемая для масштабирования d
Возвращает:: d × 2^scaleFactor
С версии:: 1.6

scalb

public static float scalb(float f, int scaleFactor)

Возвращает f × 2^scaleFactor, округленное так, как если бы вычисление выполнялось одним умножением чисел с плавающей точкой с корректным округлением. Если экспонента результата находится в диапазоне от Float.MIN_EXPONENT до Float.MAX_EXPONENT, ответ вычисляется точно. Если экспонента результата превышала бы


Float.MAX_EXPONENT

scalb(scalb(x, n),
-n)

может не равняться x. Если результат не является NaN, он имеет тот же знак, что и f.

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

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

Примечание к API:: Этот метод соответствует операции scaleB, определенной в IEEE 754.
Параметры:: f — число, которое требуется масштабировать степенью двойки.; scaleFactor — степень числа 2, используемая для масштабирования f
Возвращает:: f × 2^scaleFactor
С версии:: 1.6

unsignedMultiplyExact

public static int unsignedMultiplyExact(int x, int y)

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

Параметры:: x — первое беззнаковое значение; y — второе беззнаковое значение
Возвращает:: результат
Выбрасывает:: ArithmeticException — если результат выходит за пределы беззнакового int
С версии:: 25

unsignedMultiplyExact

public static long unsignedMultiplyExact(long x, int y)

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

Параметры:: x — первое беззнаковое значение; y — второе беззнаковое значение
Возвращает:: результат
Выбрасывает:: ArithmeticException — если результат выходит за пределы беззнакового long
С версии:: 25

unsignedMultiplyExact

public static long unsignedMultiplyExact(long x, long y)

Параметры:: x — первое беззнаковое значение; y — второе беззнаковое значение
Возвращает:: результат
Выбрасывает:: ArithmeticException — если результат выходит за пределы беззнакового long
С версии:: 25

powExact

public static int powExact(int x, int n)

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

Параметры:: x — основание.; n — показатель степени.
Возвращает:: x в степени n.
Выбрасывает:: ArithmeticException — если n отрицательно или результат выходит за пределы int.
С версии:: 25

unsignedPowExact

public static int unsignedPowExact(int x, int n)

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

Параметры:: x — беззнаковое основание.; n — показатель степени.
Возвращает:: x в степени n.
Выбрасывает:: ArithmeticException — если n отрицательно или результат выходит за пределы беззнакового int.
С версии:: 25

powExact

public static long powExact(long x, int n)

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

Параметры:: x — основание.; n — показатель степени.
Возвращает:: x в степени n.
Выбрасывает:: ArithmeticException — если n отрицательно или результат выходит за пределы long.
С версии:: 25

unsignedPowExact

public static long unsignedPowExact(long x, int n)

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

Параметры:: x — беззнаковое основание.; n — показатель степени.
Возвращает:: x в степени n.
Выбрасывает:: ArithmeticException — если n отрицательно или результат выходит за пределы беззнакового long.
С версии:: 25

© 1993, 2025, 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.

Класс Math

Рекомендуемые операции IEEE 754

Краткое описание полей

Краткое описание методов

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

Подробное описание полей

E

PI

TAU

Подробное описание методов

sin

cos

tan

asin

acos

atan

toRadians

toDegrees

exp

log

log10

sqrt

cbrt

IEEEremainder

ceil

floor

rint

atan2

pow

round

round

random

addExact

addExact

subtractExact

subtractExact

multiplyExact

multiplyExact

multiplyExact

divideExact

divideExact

floorDivExact

floorDivExact

ceilDivExact

ceilDivExact

incrementExact

incrementExact

decrementExact

decrementExact

negateExact

negateExact

toIntExact

multiplyFull

multiplyHigh

unsignedMultiplyHigh

floorDiv

floorDiv

floorDiv

floorMod

floorMod

floorMod

ceilDiv

ceilDiv

ceilDiv

ceilMod

ceilMod

ceilMod

abs

absExact

abs

absExact

abs

abs

max

max

max

max

min

min

min