Класс StrictMath

java.lang.Object
- java.lang.StrictMath

public final class StrictMath
extends Object

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

Для обеспечения переносимости программ Java определения некоторых числовых функций в этом пакете требуют, чтобы они давали те же результаты, что и определенные опубликованные алгоритмы. Эти алгоритмы доступны из известной сетевой библиотеки netlib как пакет "Freely Distributable Math Library", fdlibm. Эти алгоритмы, написанные на языке программирования C, затем должны пониматься как выполняемые со всеми операциями с плавающей запятой, следующими правилам арифметики с плавающей запятой Java.

Библиотека математических функций Java определена относительно fdlibm версии 5.3. Где fdlibm предоставляет более одного определения функции (например, acos), используется версия "IEEE 754 core function" (расположенная в файле, имя которого начинается с буквы e). Методы, которые требуют fdlibm семантики, это sin, cos, tan, asin, acos, atan, exp, log, log10, cbrt, atan2, pow, sinh, cosh, tanh, hypot, expm1, и log1p.

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

С момента:: 1.3

Сводка полей

Модификатор и Тип	Поле и описание
`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 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 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, long y)` Возвращает произведение аргументов, выбрасывая исключение, если результат выходит за пределы `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.
Если аргумент равен нулю, то результат равен нулю с тем же знаком, что и аргумент.

Параметры:: 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 в радианах.

toDegrees

public static double toDegrees(double angrad)

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

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

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

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

Параметры:: a - значение.
Возвращает:: положительный квадратный корень из a.

cbrt

public static double cbrt(double a)

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

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

Параметры:: 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, то результатом является отрицательный ноль.

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

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

floor

public static double floor(double a)

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

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

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

rint

public static double rint(double a)

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

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

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

atan2

public static double atan2(double y,
                           double x)

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

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

Параметры:: 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. Значение является фиксированной точкой одноаргументного метода, если и только если результат применения метода к значению равен этому значению.)

Параметры:: 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
См. также:: Math.addExact(int,int)

addExact

public static long addExact(long x,
                            long y)

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

Параметры:: x - первое значение; y - второе значение
Возвращает:: результат
Исключения:: ArithmeticException - если результат переполняет long
С:: 1.8
См. также:: Math.addExact(long,long)

subtractExact

public static int subtractExact(int x,
                                int y)

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

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

subtractExact

public static long subtractExact(long x,
                                 long y)

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

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

multiplyExact

public static int multiplyExact(int x,
                                int y)

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

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

multiplyExact

public static long multiplyExact(long x,
                                 long y)

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

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

toIntExact

public static int toIntExact(long value)

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

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

floorDiv

public static int floorDiv(int x,
                           int y)

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

См. Math.floorDiv для примеров и сравнения с оператором целочисленного деления /.

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

floorDiv

public static long floorDiv(long x,
                            long y)

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

См. Math.floorDiv для примеров и сравнения с оператором целочисленного деления /.

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

floorMod

public static int floorMod(int x,
                           int y)

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

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

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

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

См. Math.floorMod для примеров и сравнения с оператором %.

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

floorMod

public static long floorMod(long x,
                            long y)

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

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

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

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

См. Math.floorMod для примеров и сравнения с оператором %.

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

abs

public static int abs(int a)

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

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

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

Возвращает большее из двух целых значений. То есть, результат - аргумент, более близкий к значению 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 значением, следующим за ним по величине. Обратите внимание, что для не-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 значением, следующим за ним по величине. Обратите внимание, что для не-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 — значение с плавающей точкой, для которого требуется signum
Возвращает:: функция signum аргумента
С:: 1.5

sinh

public static double sinh(double x)

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

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

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

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

cosh

public static double cosh(double x)

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

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

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

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

tanh

public static double tanh(double x)

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

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

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

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

hypot

public static double hypot(double x,
                           double y)

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

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

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

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

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

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

copySign

public static double copySign(double magnitude,
                              double sign)

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

Параметры:: 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 - значение типа float
Возвращает:: несмещённый показатель степени аргумента
С тех пор:: 1.6

getExponent

public static int getExponent(double d)

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

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

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

nextAfter

public static double nextAfter(double start,
                               double direction)

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

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

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

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

nextAfter

public static float nextAfter(float start,
                              double direction)

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

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

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

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

nextUp

public static double nextUp(double d)

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

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

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

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