Класс Math

java.lang.Object

java.lang.Math

public final class Math extends Object

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

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

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

Качество спецификаций реализации касается двух свойств: точности возвращаемого результата и монотонности метода. Точность плавающей точки Math методов измеряется в терминах ulps, единиц в последнем разряде. Для данного формата с плавающей запятой ulp конкретного вещественного значения — это расстояние между двумя значениями с плавающей запятой, ограничивающими это численное значение. При обсуждении точности метода в целом, а не на конкретном аргументе, указанное число ulps относится к наихудшей ошибке на любом аргументе. Если метод всегда имеет ошибку меньше 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`, которое ближе всего к пи (π), отношению окружности круга к его диаметру.
`static final double`	`TAU`	Значение `double`, которое ближе всего к тау (τ), отношению окружности круга к его радиусу.

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

Модификатор и тип	Метод	Описание
`static double`	`abs(double a)`	Возвращает абсолютное значение `double`.
`static float`	`abs(float a)`	Возвращает абсолютное значение `float`.
`static int`	`abs(int a)`	Возвращает абсолютное значение `int`.
`static long`	`abs(long a)`	Возвращает абсолютное значение `long`.
`static int`	`absExact(int a)`	Возвращает математическое абсолютное значение `int`, если оно точно представимо как `int`, выбрасывая `ArithmeticException`, если результат выходит за пределы положительного диапазона `int`.
`static long`	`absExact(long a)`	Возвращает математическое абсолютное значение `long`, если оно точно представимо как `long`, выбрасывая `ArithmeticException`, если результат выходит за пределы положительного диапазона `long`.
`static double`	`acos(double a)`	Возвращает арккосинус значения; возвращаемый угол находится в диапазоне от 0,0 до π.
`static int`	`addExact(int x, int y)`	Возвращает сумму аргументов, выбрасывая исключение, если результат выходит за пределы `int`.
`static long`	`addExact(long x, long y)`	Возвращает сумму аргументов, выбрасывая исключение, если результат выходит за пределы `long`.
`static double`	`asin(double a)`	Возвращает арксинус значения; возвращаемый угол находится в диапазоне от −π/2 до π/2.
`static double`	`atan(double a)`	Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от −π/2 до π/2.
`static double`	`atan2(double y, double x)`	Возвращает угол θ из преобразования прямоугольных координат (`x`, `y`) в полярные координаты (r, θ).
`static double`	`cbrt(double a)`	Возвращает кубический корень из `double`.
`static double`	`ceil(double a)`	Возвращает наименьшее (ближайшее к отрицательной бесконечности) значение `double`, которое больше или равно аргументу и равно целому числу.
`static 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)`	Возвращает логарифм по основанию 10 значения `double`.
`static double`	`log1p(double x)`	Возвращает натуральный логарифм суммы аргумента и 1.
`static double`	`max(double a, double b)`	Возвращает большее из двух значений `double`.
`static float`	`max(float a, float b)`	Возвращает большее из двух значений `float`.
`static int`	`max(int a, int b)`	Возвращает большее из двух значений `int`.
`static long`	`max(long a, long b)`	Возвращает большее из двух значений `long`.
`static double`	`min(double a, double b)`	Возвращает меньшее из двух значений `double`.
`static float`	`min(float a, float b)`	Возвращает меньшее из двух значений `float`.
`static int`	`min(int a, int b)`	Возвращает меньшее из двух значений `int`.
`static long`	`min(long a, long b)`	Возвращает меньшее из двух значений `long`.
`static int`	`multiplyExact(int x, int y)`	Возвращает произведение аргументов, выбрасывая исключение, если результат выходит за пределы `int`.
`static long`	`multiplyExact(long x, int y)`	Возвращает произведение аргументов, выбрасывая исключение, если результат выходит за пределы `long`.
`static long`	`multiplyExact(long x, long y)`	Возвращает произведение аргументов, выбрасывая исключение, если результат выходит за пределы `long`.
`static long`	`multiplyFull(int x, int y)`	Возвращает точное математическое произведение аргументов.
`static long`	`multiplyHigh(long x, long y)`	Возвращает в виде `long` наиболее значимые 64 бита 128-битного произведения двух 64-битных множителей.
`static int`	`negateExact(int a)`	Возвращает отрицание аргумента, выбрасывая исключение, если результат выходит за пределы `int`.
`static long`	`negateExact(long a)`	Возвращает отрицание аргумента, выбрасывая исключение, если результат выходит за пределы `long`.
`static double`	`nextAfter(double start, double direction)`	Возвращает число с плавающей точкой, смежное с первым аргументом в направлении второго аргумента.
`static float`	`nextAfter(float start, double direction)`	Возвращает число с плавающей точкой, смежное с первым аргументом в направлении второго аргумента.
`static double`	`nextDown(double d)`	Возвращает значение с плавающей точкой, смежное со значением `d` в направлении отрицательной бесконечности.
`static float`	`nextDown(float f)`	Возвращает значение с плавающей точкой, смежное со значением `f` в направлении отрицательной бесконечности.
`static double`	`nextUp(double d)`	Возвращает значение с плавающей точкой, смежное со значением `d` в направлении положительной бесконечности.
`static float`	`nextUp(float f)`	Возвращает значение с плавающей точкой, смежное со значением `f` в направлении положительной бесконечности.
`static double`	`pow(double a, double b)`	Возвращает значение первого аргумента, возведенного в степень второго аргумента.
`static double`	`random()`	Возвращает значение `double` с положительным знаком, большее или равное `0.0` и меньшее `1.0`.
`static double`	`rint(double a)`	Возвращает значение `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)`	Возвращает функцию signum аргумента; ноль, если аргумент равен нулю, 1,0, если аргумент больше нуля, -1,0, если аргумент меньше нуля.
`static float`	`signum(float f)`	Возвращает функцию signum аргумента; ноль, если аргумент равен нулю, 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 long`	`unsignedMultiplyHigh(long x, long y)`	Возвращает в виде `long` наиболее значимые 64 бита незначащего 128-битного произведения двух беззнаковых 64-битных множителей.

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

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

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

E

public static final double E

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

См. также:

PI

public static final double PI

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

См. также:

TAU

public static final double TAU

Значение, наиболее близкое к 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)

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

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

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

sqrt

public static double sqrt(double a)

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

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

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

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

END_OF_DOCUMENT_MARKER

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 в диапазоне от −π до π. Особые случаи:

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

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

Примечание 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)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

round

public static long round(double a)

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

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

Параметры:

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

Возвращает:

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

См. также:

random

public static double random()

Возвращает значение с положительным знаком, большее или равное 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;

Возвращает:

псевдослучайное значение, большее или равное 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.

Parameters:: x - первое значение; y - второе значение
Returns:: результат
Throws:: ArithmeticException - если результат выходит за пределы int
Since:: 1.8

multiplyExact

public static long multiplyExact(long x, int y)

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

Parameters:: x - первое значение; y - второе значение
Returns:: результат
Throws:: ArithmeticException - если результат выходит за пределы long
Since:: 9

multiplyExact

public static long multiplyExact(long x, long y)

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

Parameters:: x - первое значение; y - второе значение
Returns:: результат
Throws:: ArithmeticException - если результат выходит за пределы long
Since:: 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).

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

Parameters:: x - делимое; y - делитель
Returns:: частное x / y
Throws:: ArithmeticException - если y равно нулю или частное выходит за пределы int
См. Спецификацию языка Java:: 15.17.2 Оператор деления /
Since:: 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).

Parameters:: x - делимое; y - делитель
Returns:: частное x / y
Throws:: ArithmeticException - если y равно нулю или частное выходит за пределы long
См. Спецификацию языка Java:: 15.17.2 Оператор деления /
Since:: 18

floorDivExact

public static int floorDivExact(int x, int y)

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

Метод floor modulus floorMod(int,int) является подходящим аналогом как для этого метода, так и для метода floorDiv(int,int).

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

See Also:

floorDivExact

public static long floorDivExact(long x, long y)

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

Метод floor modulus floorMod(long,long) является подходящим аналогом как для этого метода, так и для метода floorDiv(long,long).

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

See Also:

ceilDivExact

public static int ceilDivExact(int x, int y)

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

Метод ceil modulus ceilMod(int,int) является подходящим аналогом как для этого метода, так и для метода ceilDiv(int,int).

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

See Also:

ceilDivExact

public static long ceilDivExact(long x, long y)

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

Метод ceil modulus ceilMod(long,long) является подходящим аналогом как для этого метода, так и для метода ceilDiv(long,long).

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

See Also:

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 - делитель

Возвращает:

Исключения:

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

С момента:

См. также:

floorDiv

public static long floorDiv(long x, long y)

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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

С момента:

1.8

См. также:

floorMod

public static int floorMod(int x, int y)

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

Остаток от деления по методу floor — это 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 - делитель

Возвращает:

остаток от деления по методу floor x - (floorDiv(x, y) * y)

Исключения:

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

С:

1.8

См. также:

floorMod

public static int floorMod(long x, int y)

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

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

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

остаток от деления по методу floor x - (floorDiv(x, y) * y)

Исключения:

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

С:

См. также:

floorMod

public static long floorMod(long x, long y)

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

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

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

остаток от деления по методу floor x - (floorDiv(x, y) * y)

Исключения:

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

С:

1.8

См. также:

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)

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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

С:

См. также:

ceilMod

public static int ceilMod(int x, int y)

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

Остаток от деления по методу ceil — это 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 - делитель

Возвращает:

остаток от деления по методу ceil x - (ceilDiv(x, y) * y)

Исключения:

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

С:

См. также:

ceilMod

public static int ceilMod(long x, int y)

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

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

Связь между 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, выбрасывая ArithmeticException, если результат превышает положительный диапазон int.

Поскольку диапазон целых чисел со знаком дополнения до двух ассиметричен с одним дополнительным отрицательным значением (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, выбрасывая ArithmeticException, если результат превышает положительный диапазон long.

Поскольку диапазон целых чисел со знаком дополнения до двух ассиметричен с одним дополнительным отрицательным значением (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)

Возвращает результат операции умножения-сложения (fused multiply-add) для трех аргументов; то есть возвращает точный результат умножения первых двух аргументов, сложенного с третьим аргументом, и затем один раз округлённого до ближайшего 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)

Возвращает результат операции «умножение-сложение» (fused multiply-add) для трёх аргументов; то есть, возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, и затем округлённое один раз до ближайшего float. Округление выполняется с использованием режима округления до ближайшего чётного round to nearest even. В отличие от этого, если 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 — это положительное расстояние между этим значением с плавающей точкой и следующим значением с плавающей точкой большей величины. Обратите внимание, что для не-NaN x, 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 — это положительное расстояние между этим значением с плавающей точкой и следующим значением с плавающей точкой большей величины. Обратите внимание, что для не-NaN x, 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
Возвращает:: функцию знака аргумента
С версии:: 1.5

signum

public static float signum(float f)

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

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

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

Параметры:: f - значение с плавающей точкой, для которого необходимо вернуть signum
Возвращает:: функцию знака аргумента
С версии:: 1.5

sinh

public static double sinh(double x)

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

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

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

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

Параметры:: 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 ulps от точного результата.

Параметры:: 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). Обратите внимание, что абсолютное значение точного тангенса всегда меньше 1.

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

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

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

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

hypot

public static double hypot(double x, double y)

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

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

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

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

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

END_OF_DOCUMENT_MARKER

log1p

public static double log1p(double x)

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

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

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

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

copySign

public static double copySign(double magnitude, double sign)

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

Примечание 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

END_OF_DOCUMENT_MARKER

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 - степень двойки, используемая для масштабирования 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(x, n) является субнормальным,

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

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

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

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

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

© 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.
https://download.java.net/java/early_access/jdk24/docs/api/java.base/java/lang/Math.html

Класс Math

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

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

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

Методы, объявленные в классе java.lang.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