Класс 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 и необходимо обнаружить ошибки переполнения, методы addExact, subtractExact, multiplyExact, и toIntExact выбрасывают ArithmeticException при переполнении результата. Для других арифметических операций, таких как деление, абсолютное значение, инкремент, декремент и отрицание, переполнение происходит только при определенном минимальном или максимальном значении и должно проверяться на соответствие минимальному или максимальному значению соответственно.

Since:: JDK1.0

Поля

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

Методы

Модификатор и тип	Метод и описание
`static double`	`abs(double a)` Возвращает абсолютное значение `double` значения.
`static float`	`abs(float a)` Возвращает абсолютное значение `float` значения.
`static int`	`abs(int a)` Возвращает абсолютное значение `int` значения.
`static long`	`abs(long a)` Возвращает абсолютное значение `long` значения.
`static double`	`acos(double a)` Возвращает арккосинус значения; возвращаемый угол находится в диапазоне от 0,0 до π.
`static int`	`addExact(int x, int y)` Возвращает сумму своих аргументов, выбросив исключение, если результат превышает пределы `int`.
`static long`	`addExact(long x, long y)` Возвращает сумму своих аргументов, выбросив исключение, если результат превышает пределы `long`.
`static double`	`asin(double a)` Возвращает арксинус значения; возвращаемый угол находится в диапазоне от -π/2 до π/2.
`static double`	`atan(double a)` Возвращает арктангенс значения; возвращаемый угол находится в диапазоне от -π/2 до π/2.
`static double`	`atan2(double y, double x)` Возвращает угол θ из преобразования прямоугольных координат (`x`, `y`) в полярные координаты (r, θ).
`static double`	`cbrt(double a)` Возвращает кубический корень из `double` значения.
`static double`	`ceil(double a)` Возвращает наименьшее (ближайшее к отрицательной бесконечности) `double` значение, которое больше или равно аргументу и равно целому математическому числу.
`static double`	`copySign(double magnitude, double sign)` Возвращает первый с плавающей точкой аргумент со знаком второго с плавающей точкой аргумента.
`static float`	`copySign(float magnitude, float sign)` Возвращает первый с плавающей точкой аргумент со знаком второго с плавающей точкой аргумента.
`static double`	`cos(double a)` Возвращает тригонометрический косинус угла.
`static double`	`cosh(double x)` Возвращает гиперболический косинус `double` значения.
`static int`	`decrementExact(int a)` Возвращает аргумент, уменьшенный на единицу, выбросив исключение, если результат превышает пределы `int`.
`static long`	`decrementExact(long a)` Возвращает аргумент, уменьшенный на единицу, выбросив исключение, если результат превышает пределы `long`.
`static double`	`exp(double a)` Возвращает число Эйлера e в степени `double` значения.
`static double`	`expm1(double x)` Возвращает e^x - 1.
`static double`	`floor(double a)` Возвращает наибольшее (ближайшее к положительной бесконечности) `double` значение, которое меньше или равно аргументу и равно целому математическому числу.
`static int`	`floorDiv(int x, int y)` Возвращает наибольшее (ближайшее к положительной бесконечности) `int` значение, которое меньше или равно алгебраическому частному.
`static long`	`floorDiv(long x, long y)` Возвращает наибольшее (ближайшее к положительной бесконечности) `long` значение, которое меньше или равно алгебраическому частному.
`static int`	`floorMod(int x, int y)` Возвращает модуль от деления с округлением к наименьшему целому для `int` аргументов.
`static long`	`floorMod(long x, long y)` Возвращает модуль от деления с округлением к наименьшему целому для `long` аргументов.
`static int`	`getExponent(double d)` Возвращает смещённый показатель степени, используемый в представлении `double`.
`static int`	`getExponent(float f)` Возвращает смещённый показатель степени, используемый в представлении `float`.
`static double`	`hypot(double x, double y)` Возвращает sqrt(x² +y²) без промежуточного переполнения или потери точности.
`static double`	`IEEEremainder(double f1, double f2)` Вычисляет операцию нахождения остатка от деления для двух аргументов в соответствии со стандартом IEEE 754.
`static int`	`incrementExact(int a)` Возвращает аргумент, увеличенный на единицу, выбросив исключение, если результат превышает пределы `int`.
`static long`	`incrementExact(long a)` Возвращает аргумент, увеличенный на единицу, выбросив исключение, если результат превышает пределы `long`.
`static double`	`log(double a)` Возвращает натуральный логарифм (по основанию e) `double` значения.
`static double`	`log10(double a)` Возвращает десятичный логарифм `double` значения.
`static double`	`log1p(double x)` Возвращает натуральный логарифм суммы аргумента и 1.
`static double`	`max(double a, double b)` Возвращает большее из двух `double` значений.
`static float`	`max(float a, float b)` Возвращает большее из двух `float` значений.
`static int`	`max(int a, int b)` Возвращает большее из двух `int` значений.
`static long`	`max(long a, long b)` Возвращает большее из двух `long` значений.
`static double`	`min(double a, double b)` Возвращает меньшее из двух `double` значений.
`static float`	`min(float a, float b)` Возвращает меньшее из двух `float` значений.
`static int`	`min(int a, int b)` Возвращает произведение аргументов, выбросив исключение, если результат превышает пределы `int`.
`static long`	`min(long a, long b)` Возвращает произведение аргументов, выбросив исключение, если результат превышает пределы `long`.
`static int`	`multiplyExact(int x, int y)` Возвращает отрицание аргумента, выбросив исключение, если результат превышает пределы `int`.
`static long`	`multiplyExact(long x, long y)` Возвращает отрицание аргумента, выбросив исключение, если результат превышает пределы `long`.
`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 аргумента.

Методы, унаследованные от класса 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, отношению длины окружности к её диаметру.

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

Методы

sin

public static double sin(double a)

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

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

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

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

cos

public static double cos(double a)

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

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

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

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

atan

public static double atan(double a)

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

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

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

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

log

public static double log(double a)

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

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

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

log10

public static double log10(double a)

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

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

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

sqrt

public static double sqrt(double a)

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

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

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

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

cbrt

public static double cbrt(double a)

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

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

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

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

IEEEremainder

public static double IEEEremainder(double f1,
                                   double f2)

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

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

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

ceil

public static double ceil(double a)

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

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

Обратите внимание, что значение Math.ceil(x) точно равно значению -Math.floor(-x).

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

floor

public static double floor(double a)

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

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

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

rint

public static double rint(double a)

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

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

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

atan2

public static double atan2(double y,
                           double x)

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

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

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

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

pow

public static double pow(double a,
                         double b)

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

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

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

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

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

round

public static int round(float a)

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

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

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

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

round

public static long round(double a)

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

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

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

random

public static double random()

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

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

new java.util.Random()

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

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

Возвращает:: псевдослучайное значение с плавающей точкой, большее или равное 0.0 и меньшее 1.0.
См. также:: Random.nextDouble()

addExact

public static int addExact(int x,
                           int y)

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

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

addExact

public static long addExact(long x,
                            long y)

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

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

subtractExact

public static int subtractExact(int x,
                                int y)

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

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

subtractExact

public static long subtractExact(long x,
                                 long y)

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

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

multiplyExact

public static int multiplyExact(int x,
                                int y)

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

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

multiplyExact

public static long multiplyExact(long x,
                                 long y)

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

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

incrementExact

public static int incrementExact(int a)

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

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

incrementExact

public static long incrementExact(long a)

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

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

decrementExact

public static int decrementExact(int a)

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

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

decrementExact

public static long decrementExact(long a)

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

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

negateExact

public static int negateExact(int a)

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

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

negateExact

public static long negateExact(long a)

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

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

toIntExact

public static int toIntExact(long value)

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

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

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 - делитель
Возвращает:: наибольшее (ближайшее к положительной бесконечности) int значение, которое меньше или равно алгебраическому частному.
Выбрасывает:: ArithmeticException - если делитель y равен нулю
С:: 1.8
См. также:: floorMod(int, int), floor(double)

floorDiv

public static long floorDiv(long x,
                            long y)

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

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

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

floorMod

public static int floorMod(int x,
                           int y)

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

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

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

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

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

Примеры:

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

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

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

floorMod

public static long floorMod(long x,
                            long y)

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

Остаток floor имеет тот же знак, что и делитель 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 равен нулю
С:: 1.8
См. также:: floorDiv(long, long)

abs

public static int abs(int a)

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

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

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

abs

public static long abs(long a)

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

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

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

abs

public static float abs(float a)

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

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

Другими словами, результат такой же, как значение выражения:

Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))

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

abs

public static double abs(double a)

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

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

Другими словами, результат такой же, как значение выражения:

Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)

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

max

public static int max(int a,
                      int b)

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

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

max

public static long max(long a,
                       long b)

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

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

max

public static float max(float a,
                        float b)

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

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

max

public static double max(double a,
                         double b)

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

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

min

public static int min(int a,
                      int b)

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

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

min

public static long min(long a,
                       long b)

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

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

min

public static float min(float a,
                        float b)

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

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

min

public static double min(double a,
                         double b)

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

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

ulp

public static double ulp(double d)

Возвращает размер ulp аргумента. ULP (единица в последнем разряде) для double — это положительное расстояние между этим значением с плавающей точкой и double значением, следующим по величине. Обратите внимание, что для non-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 — это положительное расстояние между этим значением с плавающей точкой и float значением, следующим по величине. Обратите внимание, что для non-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
Возвращает:: функция signum аргумента
С:: 1.5

signum

public static float signum(float f)

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

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

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

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

sinh

public static double sinh(double x)

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

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

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

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

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

cosh

public static double cosh(double x)

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

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

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

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

Параметры:: 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 единиц последнего разряда от точного результата. Результат tanh для любого конечного входного значения должен иметь абсолютное значение, меньшее или равное 1. Обратите внимание, что как только точный результат tanh окажется в пределах 1/2 единицы последнего разряда от предельного значения ±1, следует вернуть корректно сгруппированные ±1.0.

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

hypot

public static double hypot(double x,
                           double y)

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

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

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

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

Параметры:: 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 единицы последнего разряда от точного результата. Результаты должны быть полумонотонными. Результат expm1 для любого конечного входного значения должен быть больше или равен -1.0. Обратите внимание, что как только точный результат e^x - 1 окажется в пределах 1/2 единицы последнего разряда от предельного значения -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 единицы последнего разряда от точного результата. Результаты должны быть полумонотонными.

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

copySign

public static double copySign(double magnitude,
                              double sign)

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

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

copySign

public static float copySign(float magnitude,
                             float sign)

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

getExponent

public static int getExponent(float f)

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

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

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

getExponent

public static int getExponent(double d)

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

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

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

nextAfter

public static double nextAfter(double start,
                               double direction)

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

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

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

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

nextAfter

public static float nextAfter(float start,
                              double direction)

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

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

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

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

nextUp

public static double nextUp(double d)

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

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

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

Параметры:: d - начальное значение с плавающей точкой
Возвращает:: Смежное значение с плавающей точкой, более близкое к положительной бесконечности.
С:: 1.6

nextUp

public static float nextUp(float f)

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

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

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

Параметры:: f - начальное значение с плавающей точкой
Возвращает:: Смежное значение с плавающей точкой, более близкое к положительной бесконечности.
С:: 1.6

nextDown

public static double nextDown(double d)

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

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

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

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

nextDown

public static float nextDown(float f)

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

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

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

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

scalb

public static double scalb(double d,
                           int scaleFactor)

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

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

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

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

scalb

public static float scalb(float f,
                          int scaleFactor)

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

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

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

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

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.