Класс 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`, которое ближе всего к π (пи), отношению окружности круга к его диаметру.
`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 до pi.
`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`	`atan(double a)`	Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от -pi/2 до pi/2.
`static double`	`atan2(double y, double x)`	Возвращает угол theta из преобразования прямоугольных координат (`x`, `y`) в полярные координаты (r, theta).
`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²) без промежуточного переполнения или подпотока.

END_OF_DOCUMENT_MARKER

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

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

cos

public static double cos(double a)

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

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

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

tan

public static double tan(double a)

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

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

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

cbrt

public static double cbrt(double a)

Возвращает кубический корень из double значения. Для положительных конечных x,

cbrt(-x) ==
 -cbrt(x)

; то есть кубический корень из отрицательного значения является отрицательным кубическим корнем из абсолютного значения этого значения. Специальные случаи:

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

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

Параметры:: 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.
Если первый аргумент — положительный ноль, а второй — положительный, или первый аргумент — положительный и конечный, а второй — положительная бесконечность, то результатом является положительный ноль.
Если первый аргумент — отрицательный ноль, а второй — положительный, или первый аргумент — отрицательный и конечный, а второй — положительная бесконечность, то результатом является отрицательный ноль.
Если первый аргумент — положительный ноль, а второй — отрицательный, или первый аргумент — положительный и конечный, а второй — отрицательная бесконечность, то результатом является значение, наиболее близкое к pi.
Если первый аргумент — отрицательный ноль, а второй — отрицательный, или первый аргумент — отрицательный и конечный, а второй — отрицательная бесконечность, то результатом является значение, наиболее близкое к -pi.
Если первый аргумент — положительный, а второй — положительный или отрицательный ноль, или первый аргумент — положительная бесконечность, а второй — конечный, то результатом является значение, наиболее близкое к pi/2.
Если первый аргумент — отрицательный, а второй — положительный или отрицательный ноль, или первый аргумент — отрицательная бесконечность, а второй — конечный, то результатом является значение, наиболее близкое к -pi/2.
Если оба аргумента — положительная бесконечность, то результатом является значение, наиболее близкое к pi/4.
Если первый аргумент — положительная бесконечность, а второй — отрицательная бесконечность, то результатом является значение, наиболее близкое к 3*pi/4.
Если первый аргумент — отрицательная бесконечность, а второй — положительная бесконечность, то результатом является значение, наиболее близкое к -pi/4.
Если оба аргумента — отрицательная бесконечность, то результатом является значение, наиболее близкое к -3*pi/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. Значение является неподвижной точкой одноаргументного метода, если и только если результат применения метода к значению равен этому значению.)

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

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

round

public static int round(float a)

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

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

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

Parameters:

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

Returns:

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

See Also:

round

public static long round(double a)

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

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

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

Parameters:

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

Returns:

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

See Also:

random

public static double random()

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

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

new java.util.Random()

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

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

API Note:

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

Returns:

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

See Also:

addExact

public static int addExact(int x, int y)

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

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

addExact

public static long addExact(long x, long y)

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

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

subtractExact

public static int subtractExact(int x, int y)

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

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

subtractExact

public static long subtractExact(long x, long y)

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

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

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

уменьшитьНаЕдиницу

public static int decrementExact(int a)

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

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

уменьшитьНаЕдиницу

public static long decrementExact(long a)

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

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

отрицание

public static int negateExact(int a)

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

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

отрицание

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 - если значение переполняет 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.

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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

С:

1.8

См. также:

floorDiv

public static long floorDiv(long x, int y)

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

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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

С:

См. также:

floorDiv

public static long floorDiv(long x, long y)

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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

С:

1.8

См. также:

floorMod

public static int floorMod(int x, int y)

Возвращает остаток от целочисленного деления с округлением к отрицательной бесконечности (floor) аргументов.

Остаток от целочисленного деления с округлением к отрицательной бесконечности (floor) имеет тот же знак, что и делитель 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)

Исключения:

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

С:

1.8

См. также:

END_OF_DOCUMENT_MARKER

floorMod

public static int floorMod(long x, int y)

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

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

Соотношение между floorDiv и floorMod таково:

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

модуль от деления нацело 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)

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

Исключения:

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)

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

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

Параметры:

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

Возвращает:

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

См. также:

absExact

public static int absExact(int a)

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

С:

См. также:

abs

public static long abs(long a)

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

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

Параметры:

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)

Возвращает большее из двух целых значений. То есть результат — это аргумент, более близкий к значению 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)

Возвращает меньшее из двух целых значений. То есть результат — это аргумент, более близкий к значению 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 Note:: Этот метод соответствует операции минимума, определённой в IEEE 754.
Parameters:: a - аргумент.; b - другой аргумент.
Returns:: меньшее из a и b.

min

public static double min(double a, double b)

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

API Note:: Этот метод соответствует операции минимума, определённой в IEEE 754.
Parameters:: a - аргумент.; b - другой аргумент.
Returns:: меньшее из 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 с насыщением.

Parameters:: value - значение для ограничения; min - минимально допустимое значение; max - максимально допустимое значение
Returns:: ограниченное значение, которое помещается в интервал min..max
Throws:: IllegalArgumentException - если min > max
Since:: 21

clamp

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

Parameters:: value - значение для ограничения; min - минимально допустимое значение; max - максимально допустимое значение
Returns:: ограниченное значение, которое помещается в интервал min..max
Throws:: IllegalArgumentException - если min > max
Since:: 21

clamp

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

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

Parameters:: value - значение для ограничения; min - минимально допустимое значение; max - максимально допустимое значение
Returns:: ограниченное значение, которое помещается в интервал min..max
Throws:: IllegalArgumentException - если любой из аргументов min и max равен NaN, или min > max, или min равен +0.0, а max равен -0.0.
Since:: 21

clamp

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

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

Parameters:: value - значение для ограничения; min - минимально допустимое значение; max - максимально допустимое значение
Returns:: ограниченное значение, которое помещается в интервал min..max
Throws:: IllegalArgumentException - если любой из аргументов min и max равен NaN, или min > max, или min равен +0.0f, а max равен -0.0f.
Since:: 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 Note:: Этот метод соответствует операции fusedMultiplyAdd, определённой в IEEE 754.
Parameters:: a - значение; b - значение; c - значение
Returns:: (a × b + c) вычислено, как если бы с неограниченным диапазоном и точностью, и округлено один раз до ближайшего double значения
Since:: 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 Note:: Этот метод соответствует операции fusedMultiplyAdd, определённой в IEEE 754.
Parameters:: a - значение; b - значение; c - значение
Returns:: (a × b + c) вычислено, как если бы с неограниченным диапазоном и точностью, и округлено один раз до ближайшего float значения
Since:: 9

ulp

public static double ulp(double d)

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


 double

значением, следующим за ним по величине. Обратите внимание, что для не-NaN x, ulp(-x) == ulp(x).

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

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

Parameters:: d - значение с плавающей запятой, для которого необходимо вернуть ulp
Returns:: размер ulp аргумента
Since:: 1.5

ulp

public static float ulp(float f)

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

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

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

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

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

signum

public static float signum(float f)

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

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

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

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

sinh

public static double sinh(double x)

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

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

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

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

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

cosh

public static double cosh(double x)

Возвращает гиперболический косинус значения с плавающей запятой. Гиперболический косинус 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)

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

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

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

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

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

hypot

public static double hypot(double x, double y)

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

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

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

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

nextAfter

public static double nextAfter(double start, double direction)

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

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

Если любой из аргументов является NaN, возвращается NaN.
Если оба аргумента являются знаковыми нулями, возвращается второй аргумент без изменений (как следует из требования возвращать второй аргумент, если аргументы равны).
Если первый аргумент равен ±Double.MIN_VALUE и второй аргумент имеет такое значение, что результат должен иметь меньший порядок, то возвращается ноль со знаком, совпадающим со знаком первого аргумента.
Если первый аргумент является бесконечностью и второй аргумент имеет такое значение, что результат должен иметь меньший порядок, возвращается Double.MAX_VALUE с тем же знаком, что и второй аргумент.
Если первый аргумент равен ± Double.MAX_VALUE и второй аргумент имеет такое значение, что результат должен иметь больший порядок, возвращается бесконечность со знаком, совпадающим со знаком второго аргумента.

Параметры:: start - начальное значение с плавающей запятой; direction - значение, указывающее, какой из соседей первого аргумента или сам второй аргумент должен быть возвращён
Возвращаемое значение:: Число с плавающей запятой, смежное с первым аргументом в направлении второго аргумента.
С версии:: 1.6

nextAfter

public static float nextAfter(float start, double direction)

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

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

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

Параметры:: 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 Note:: Этот метод соответствует операции 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 Note:: Этот метод соответствует операции 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 Note:: Этот метод соответствует операции 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 Note:: Этот метод соответствует операции 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 Note:: Этот метод соответствует операции 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, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/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

уменьшитьНаЕдиницу

уменьшитьНаЕдиницу

отрицание

отрицание

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