Класс 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" (расположенная в файле, имя которого начинается с буквы 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, которое ближе всего к pi, отношению окружности круга к его диаметру.

Методы

Модификатор и тип Метод Описание
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)

Возвращает ex - 1.
static double floor​(double a)

Возвращает наибольшее (ближайшее к положительной бесконечности) double значение, которое меньше или равно аргументу и равно целому математическому числу.
static int floorDiv​(int x, int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) int значение, которое меньше или равно алгебраическому частному.
static long floorDiv​(long x, int y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, которое меньше или равно алгебраическому частному.
static long floorDiv​(long x, long y)

Возвращает наибольшее (ближайшее к положительной бесконечности) long значение, которое меньше или равно алгебраическому частному.
static int floorMod​(int x, int y)

Возвращает модуль отсечения по полу для int аргументов.
static int floorMod​(long x, int y)

Возвращает модуль отсечения по полу для long и int аргументов.
static long floorMod​(long x, long y)

Возвращает модуль отсечения по полу для long аргументов.
static double fma​(double a, double b, double c)

Возвращает результат умножения, сложения и округления трех аргументов; то есть, возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, а затем округляется один раз до ближайшего double.
static float fma​(float a, float b, float c)

Возвращает результат умножения, сложения и округления трех аргументов; то есть, возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, а затем округляется один раз до ближайшего float.
static int getExponent​(double d)

Возвращает смещённый экспоненту, используемый в представлении double.
static int getExponent​(float f)

Возвращает смещённый экспоненту, используемый в представлении float.
static double hypot​(double x, double y)

Возвращает sqrt(x2 +y2) без промежуточного переполнения или переполнения.
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, int y)

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

Возвращает произведение аргументов, выбрасывая исключение, если результат выходит за пределы long.
static long multiplyFull​(int x, int y)

Возвращает точное математическое произведение аргументов.
static long multiplyHigh​(long x, long y)

Возвращает как long самые значимые 64 бита 128-битного произведения двух 64-битных сомножителей.
static 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 × 2scaleFactor, округлённое так, как если бы оно выполнялось одним правильно округлённым поплавковым умножением на член множества двойных значений.
static float scalb​(float f, int scaleFactor)

Возвращает f × 2scaleFactor, округлённое так, как если бы оно выполнялось одним правильно округлённым поплавковым умножением на член множества значений с плавающей точкой.
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.
Возвращает:
значение ea, где e — основание натуральных логарифмов.

log

public static double log(double a)

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

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

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

log10

public static double log10(double a)

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

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

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

sqrt

public static double sqrt(double a)

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

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

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

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

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

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

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

round

public static int round(float a)

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

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

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

round

public static long round(double a)

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

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

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

random

public static double random()

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

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

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

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

Возвращает:
псевдослучайное double большее или равное 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,
                                 int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
Выбрасывает:
ArithmeticException - если результат переполняет long
С:
9
См. также:
Math.multiplyExact(long,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)

multiplyFull

public static long multiplyFull(int x,
                                int y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
С:
9
См. также:
Math.multiplyFull(int,int)

multiplyHigh

public static long multiplyHigh(long x,
                                long y)

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

Параметры:
x - первое значение
y - второе значение
Возвращает:
результат
С:
9
См. также:
Math.multiplyHigh(long,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,
                            int y)

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

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

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

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

Остаток от деления по модулю равен 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 - делитель
Возвращает:
остаток от деления по модулю x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
Math.floorMod(int, int), floorDiv(int, int)

floorMod

public static int floorMod(long x,
                           int y)

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

Остаток от деления по модулю равен 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 - делитель
Возвращает:
остаток от деления по модулю x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
9
См. также:
Math.floorMod(long, int), floorDiv(long, int)

floorMod

public static long floorMod(long x,
                            long y)

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

Остаток от деления по модулю равен 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 - делитель
Возвращает:
остаток от деления по модулю x - (floorDiv(x, y) * y)
Выбрасывает:
ArithmeticException - если делитель y равен нулю
С:
1.8
См. также:
Math.floorMod(long, long), 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.

Примечание API:
Как подразумевается из вышесказанного, одно из возможных реализаций этого метода дано выражением ниже, которое вычисляет float с тем же показателем и мантиссой, что и аргумент, но с гарантированным нулевым битом знака, указывающим на положительное значение:
Float.intBitsToFloat(0x7fffffff & Float.floatToRawIntBits(a))
Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

abs

public static double abs(double a)

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

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

Примечание API:
Как подразумевается из вышесказанного, одно из возможных реализаций этого метода дано выражением ниже, которое вычисляет double с тем же показателем и мантиссой, что и аргумент, но с гарантированным нулевым битом знака, указывающим на положительное значение:
Double.longBitsToDouble((Double.doubleToRawLongBits(a)<<1)>>>1)
Параметры:
a - аргумент, абсолютное значение которого требуется определить
Возвращает:
абсолютное значение аргумента.

max

public static int max(int a,
                      int b)

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

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

max

public static long max(long a,
                       long b)

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

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

max

public static float max(float a,
                        float b)

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

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

min

public static double min(double a,
                         double b)

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

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

fma

public static double fma(double a,
                         double b,
                         double c)

Возвращает результат операции умножения-сложения (fused multiply-add) для трех аргументов; то есть возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, и затем округлённое один раз до ближайшего double. Округление выполняется с использованием режима округления до ближайшего чётного. В отличие от этого, если a * b + c оценивается как обычное выражение с плавающей запятой, участвуют две ошибки округления: первая для операции умножения, вторая для операции сложения.

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

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

Обратите внимание, что fusedMac(a, 1.0, c) возвращает тот же результат, что и (a + c). Однако, fusedMac(a, b, +0.0) не всегда возвращает тот же результат, что и (a * b) так как fusedMac(-0.0, +0.0, +0.0) — +0.0, в то время как (-0.0 * +0.0) — -0.0; fusedMac(a, b, -0.0) эквивалентно (a * b).

Примечание API:
Этот метод соответствует операции fusedMultiplyAdd, определённой в стандарте IEEE 754-2008.
Параметры:
a - значение
b - значение
c - значение
Возвращает:
(a × b + c) вычислено, как будто с неограниченным диапазоном и точностью, и округлено один раз до ближайшего double значения
С:
9

fma

public static float fma(float a,
                        float b,
                        float c)

Возвращает результат операции умножения-сложения (fused multiply-add) для трех аргументов; то есть возвращает точное произведение первых двух аргументов, сложенное с третьим аргументом, и затем округлено один раз до ближайшего float. Округление выполняется с использованием режима округления до ближайшего чётного. В отличие от этого, если a * b + c оценивается как обычное выражение с плавающей запятой, участвуют две ошибки округления: первая для операции умножения, вторая для операции сложения.

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

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

Обратите внимание, что fma(a, 1.0f, c) возвращает тот же результат, что и (a + c). Однако, fma(a, b, +0.0f) не всегда возвращает тот же результат, что и (a * b) так как fma(-0.0f, +0.0f, +0.0f) — +0.0f, в то время как (-0.0f * +0.0f) — -0.0f; fma(a, b, -0.0f) эквивалентно (a * b).

Примечание к API:
Этот метод соответствует операции fusedMultiplyAdd, определенной в IEEE 754-2008.
Параметры:
a - значение
b - значение
c - значение
Возвращает:
(a × b + c) вычислено, как если бы с неограниченным диапазоном и точностью, и округленно один раз до ближайшего значения float
С версии:
9

ulp

public static double ulp(double d)

Возвращает размер ulp аргумента. Ulp, единица в последнем разряде, значения double — это положительное расстояние между этим значением с плавающей точкой и следующим за ним по величине значением double. Обратите внимание, что для не-NaN x, ulp(-x) == ulp(x).

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

  • Если аргумент равен NaN, то результат равен NaN.
  • Если аргумент равен положительной или отрицательной бесконечности, то результатом является положительная бесконечность.
  • Если аргумент равен положительному или отрицательному нулю, то результатом является Double.MIN_VALUE.
  • Если аргумент равен ±Double.MAX_VALUE, то результат равен 2971.
Параметры:
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, то результат равен 2104.
Параметры:
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 определяется как (ex - e-x)/2, где e — число Эйлера.

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

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

cosh

public static double cosh(double x)

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

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

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

tanh

public static double tanh(double x)

Возвращает гиперболический тангенс значения double. Гиперболический тангенс x определяется как (ex - e-x)/(ex + 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(x2 +y2) без промежуточного переполнения или потери точности.

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

  • Если любой из аргументов бесконечен, то результатом является положительная бесконечность.
  • Если любой из аргументов равен NaN, и ни один из аргументов не является бесконечным, то результатом является NaN.
Параметры:
x - значение
y - значение
Возвращает:
sqrt(x2 +y2) без промежуточного переполнения или потери точности
С версии:
1.5

expm1

public static double expm1(double x)

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

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

  • Если аргумент равен NaN, результат равен NaN.
  • Если аргумент равен положительной бесконечности, то результатом является положительная бесконечность.
  • Если аргумент равен отрицательной бесконечности, то результатом является -1.0.
  • Если аргумент равен нулю, то результатом является ноль с тем же знаком, что и аргумент.
Параметры:
x - показатель степени, в который необходимо возвести e при вычислении ex -1.
Возвращает:
значение ex - 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)

Возвращает первый аргумент с плавающей точкой со знаком второго аргумента с плавающей точкой. Для этого метода аргумент NaN 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.
  • Если оба аргумента — знаковые нули, возвращается значение, эквивалентное второму аргументу. (Это подразумевается требованием возвращения второго аргумента, если аргументы равны).
  • Если первый аргумент — ±Double.MIN_VALUE, а второй аргумент имеет такое значение, что результат должен иметь меньший модуль, то возвращается ноль с тем же знаком, что и у первого аргумента.
  • Если первый аргумент — бесконечность, а у второго аргумента значение такое, что результат должен иметь меньший модуль, возвращается Double.MAX_VALUE с тем же знаком, что и у второго аргумента.
  • Если первый аргумент равно ±Double.MAX_VALUE, а второй аргумент имеет значение, требующее большего модуля результата, возвращается бесконечность с тем же знаком, что и у первого аргумента.
Параметры:
start — начальное значение числа с плавающей точкой
direction — значение, указывающее, какой из соседей start или start должен быть возвращен
Возвращает:
Число с плавающей точкой, смежное с start в направлении direction.
С:
1.6

nextAfter

public static float nextAfter(float start,
                              double direction)

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

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

  • Если любой из аргументов — NaN, возвращается NaN.
  • Если оба аргумента — знаковые нули, возвращается значение, эквивалентное второму аргументу.
  • Если первый аргумент — ±Float.MIN_VALUE, а второй аргумент имеет такое значение, что результат должен иметь меньший модуль, то возвращается ноль с тем же знаком, что и у первого аргумента.
  • Если первый аргумент — бесконечность, а у второго аргумента значение такое, что результат должен иметь меньший модуль, возвращается Float.MAX_VALUE с тем же знаком, что и у второго аргумента.
  • Если первый аргумент равно ±Float.MAX_VALUE, а второй аргумент имеет значение, требующее большего модуля результата, возвращается бесконечность с тем же знаком, что и у первого аргумента.
Параметры:
start — начальное значение числа с плавающей точкой
direction — значение, указывающее, какой из соседей 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)

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

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

  • Если первый аргумент — NaN, возвращается NaN.
  • Если первый аргумент — бесконечность, возвращается бесконечность с тем же знаком.
  • Если первый аргумент — ноль, возвращается ноль с тем же знаком.
Параметры:
d — число, которое необходимо масштабировать с помощью степени двойки.
scaleFactor — степень двойки, используемая для масштабирования d
Возвращает:
x × 2a
С:
1.6

scalb

public static float scalb(float f,
                          int scaleFactor)

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

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

  • Если первый аргумент — NaN, возвращается NaN.
  • Если первый аргумент — бесконечность, возвращается бесконечность с тем же знаком.
  • Если первый аргумент — ноль, возвращается ноль с тем же знаком.
Параметры:
f — число, которое необходимо масштабировать с помощью степени двойки.
scaleFactor — степень двойки, используемая для масштабирования f
Возвращает:
x × 2a
С:
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.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StrictMath.html

Spec-Zone .ru
спецификации, руководства, описания, API