Класс Math

java.lang.Object

java.lang.Math

public final class Math extends Object

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

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

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

Качество реализаций спецификаций касается двух свойств: точности возвращаемого результата и монотонности метода. Точность плавающей точки Math методов измеряется в терминах ulp, единиц в последнем разряде. Для данного формата с плавающей запятой ulp конкретного действительного числового значения — это расстояние между двумя значениями с плавающей запятой, ограничивающими это числовое значение. При обсуждении точности метода в целом, а не в конкретной точке, приводимое число ulp относится к наихудшей ошибке в любой точке. Если метод всегда имеет ошибку менее 0,5 ulp, метод всегда возвращает число с плавающей точкой, ближайшее к точному результату; такой метод правильно округлен. Правильно округленный метод, как правило, является наилучшим приближением с плавающей запятой; однако для многих методов с плавающей запятой правильно округлять их непрактично. Вместо этого для класса Math допускается большая погрешность в 1 или 2 ulp для некоторых методов. Неформально, с ограничением погрешности в 1 ulp, когда точный результат является представимым числом, точный результат должен возвращаться как вычисленный результат; в противном случае могут возвращаться два числа с плавающей точкой, ограничивающие точный результат. Для точных результатов большой величины один из концов интервала может быть бесконечным. Помимо точности в отдельных точках, важно поддерживать правильные отношения между методом в различных точках. Поэтому большинство методов с ошибками более 0,5 ulp должны быть полумонотонными: когда математическая функция не убывает, так же, как и её приближение с плавающей точкой, аналогично, когда математическая функция не возрастает, так же, как и её приближение с плавающей точкой. Не все приближения, имеющие точность 1 ulp, автоматически удовлетворяют требованиям монотонности.

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

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

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

`static long`	`multiplyHigh(long x, long y)`	Возвращает в виде `long` наиболее значимые 64 бита 128-битного произведения двух 64-битных множителей.
`static int`	`negateExact(int a)`	Возвращает отрицание аргумента, выбросив исключение, если результат выходит за пределы `int`.
`static long`	`negateExact(long a)`	Возвращает отрицание аргумента, выбросив исключение, если результат выходит за пределы `long`.
`static double`	`nextAfter(double start, double direction)`	Возвращает ближайшее значение с плавающей точкой к первому аргументу в направлении второго аргумента.
`static float`	`nextAfter(float start, double direction)`	Возвращает ближайшее значение с плавающей точкой к первому аргументу в направлении второго аргумента.
`static double`	`nextDown(double d)`	Возвращает значение с плавающей точкой, ближайшее к `d` в направлении минус бесконечности.
`static float`	`nextDown(float f)`	Возвращает значение с плавающей точкой, ближайшее к `f` в направлении минус бесконечности.
`static double`	`nextUp(double d)`	Возвращает значение с плавающей точкой, ближайшее к `d` в направлении плюс бесконечности.
`static float`	`nextUp(float f)`	Возвращает значение с плавающей точкой, ближайшее к `f` в направлении плюс бесконечности.
`static double`	`pow(double a, double b)`	Возвращает значение первого аргумента, возведённого в степень второго аргумента.
`static double`	`random()`	Возвращает значение `double` с положительным знаком, большее или равное `0.0` и меньшее `1.0`.
`static double`	`rint(double a)`	Возвращает значение `double` , ближайшее по значению к аргументу и равному целому математическому числу.
`static long`	`round(double a)`	Возвращает ближайшее значение `long` к аргументу, привязывая к плюс бесконечности.
`static int`	`round(float a)`	Возвращает ближайшее значение `int` к аргументу, привязывая к плюс бесконечности.
`static double`	`scalb(double d, int scaleFactor)`	Возвращает `d` × 2^scaleFactor, округлённое так, как будто выполняется одно правильно округлённое умножение с плавающей точкой.
`static float`	`scalb(float f, int scaleFactor)`	Возвращает `f` × 2^scaleFactor, округлённое так, как будто выполняется одно правильно округлённое умножение с плавающей точкой.
`static double`	`signum(double d)`	Возвращает функцию знака аргумента; ноль, если аргумент равен нулю, 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)`	Возвращает размер единицы в мантиссе для аргумента.
`static float`	`ulp(float f)`	Возвращает размер единицы в мантиссе для аргумента.

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

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

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

E

public static final double E

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

См. также:

Значения константных полей

PI

public static final double PI

Значение, наиболее близкое к pi, отношению длины окружности к её диаметру.

См. также:

Значения константных полей

Подробное описание методов

sin

public static double sin(double a)

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

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

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

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

cos

public static double cos(double a)

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

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

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

tan

public static double tan(double a)

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

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

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

asin

public static double asin(double a)

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

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

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

acos

public static double acos(double a)

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

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

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

atan

public static double atan(double a)

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

Если аргумент NaN, результат NaN.
Если аргумент ноль, результат — ноль с тем же знаком, что и аргумент.
Если аргумент бесконечен, результат — значение, наиболее близкое к pi/2 с тем же знаком, что и входной аргумент.

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

toRadians

public static double toRadians(double angdeg)

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

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

toDegrees

public static double toDegrees(double angrad)

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

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

exp

public static double exp(double a)

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

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

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

log

public static double log(double a)

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

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

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

log10

public static double log10(double a)

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

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

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

sqrt

public static double sqrt(double a)

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

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

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

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

cbrt

public static double cbrt(double a)

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

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

; то есть кубокорень из отрицательного значения — это отрицание кубокорня из величины этого значения. Особые случаи:

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

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

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

IEEEremainder

public static double IEEEremainder(double f1, double f2)

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

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

Parameters:: f1 - делимое.; f2 - делитель.
Returns:: остаток от деления f1 на f2.

ceil

public static double ceil(double a)

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

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

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

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

floor

public static double floor(double a)

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

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

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

rint

public static double rint(double a)

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

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

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

atan2

public static double atan2(double y, double x)

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

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

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

API Note:

Для y с положительным знаком и конечным ненулевым x, точное математическое значение atan2 равно:

Если x > 0, atan(abs(y/x))
Если x < 0, π - atan(abs(y/x))

Parameters:

y - координата ординаты

x - координата абсциссы

Returns:

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

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

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

round

public static int round(float a)

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

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

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

Parameters:

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

Returns:

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

See Also:

round

public static long round(double a)

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

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

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

Parameters:

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

Returns:

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

See Also:

random

public static double random()

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

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

new java.util.Random()

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

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

API Note:

Так как наибольшее double значение, меньшее 1.0, равно Math.nextDown(1.0), значение x находится в закрытом диапазоне [x1,x2], где x1<=x2 может быть определено операторами


 double f = Math.random()/Math.nextDown(1.0);
 double x = x1*(1.0 - f) + x2*f;

Returns:

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

See Also:

addExact

public static int addExact(int x, int y)

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

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

addExact

public static long addExact(long x, long y)

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

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

subtractExact

public static int subtractExact(int x, int y)

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

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

subtractExact

public static long subtractExact(long x, long y)

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

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

multiplyExact

public static int multiplyExact(int x, int y)

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

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

multiplyExact

public static long multiplyExact(long x, int y)

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

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

multiplyExact

public static long multiplyExact(long x, long y)

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

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

incrementExact

public static int incrementExact(int a)

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

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

incrementExact

public static long incrementExact(long a)

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

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

decrementExact

public static int decrementExact(int a)

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

Parameters:: a - значение для уменьшения
Returns:: результат
Throws:: ArithmeticException - если результат выходит за пределы int
Since:: 1.8

decrementExact

public static long decrementExact(long a)

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

Parameters:: a - значение для уменьшения
Returns:: результат
Throws:: ArithmeticException - если результат выходит за пределы long
Since:: 1.8

negateExact

public static int negateExact(int a)

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

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

negateExact

public static long negateExact(long a)

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

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

toIntExact

public static int toIntExact(long value)

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

Parameters:: value - значение типа long
Returns:: аргумент как int
Throws:: ArithmeticException - если значение выходит за пределы int
Since:: 1.8

multiplyFull

public static long multiplyFull(int x, int y)

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

Parameters:: x - первое значение; y - второе значение
Returns:: результат
Since:: 9

multiplyHigh

public static long multiplyHigh(long x, long y)

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

Parameters:: x - первое значение; y - второе значение
Returns:: результат
Since:: 9

floorDiv

public static int floorDiv(int x, int y)

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

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

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

1.8

See Also:

floorMod(int, int)
floor(double)

floorDiv

public static long floorDiv(long x, int y)

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

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

Parameters:

x - делимое

y - делитель

Returns:

Throws:

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

Since:

See Also:

floorMod(long, int)
floor(double)

floorDiv

public static long floorDiv(long x, long y)

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

Parameters:

x - делимое

y - делитель

Returns:

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

Throws:

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

Since:

1.8

See Also:

floorMod(long, long)
floor(double)

END_OF_DOCUMENT_MARKER

floorMod

public static int floorMod(int x, int y)

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

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

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

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

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

Примеры:

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

остаток от деления, округленный до ближайшего целого x - (floorDiv(x, y) * y)

Исключения:

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

С:

1.8

См. также:

floorDiv(int, int)

floorMod

public static int floorMod(long x, int y)

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

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

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

остаток от деления, округленный до ближайшего целого x - (floorDiv(x, y) * y)

Исключения:

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

С:

См. также:

floorDiv(long, int)

floorMod

public static long floorMod(long x, long y)

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

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

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

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

Параметры:

x - делимое

y - делитель

Возвращает:

остаток от деления, округленный до ближайшего целого x - (floorDiv(x, y) * y)

Исключения:

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

С:

1.8

См. также:

floorDiv(long, long)

abs

public static int abs(int a)

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

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

Параметры:

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

Возвращает:

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

См. также:

absExact(int)

absExact

public static int absExact(int a)

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

С:

См. также:

abs(int)

abs

public static long abs(long a)

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

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

Параметры:

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

Возвращает:

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

См. также:

absExact(long)

absExact

public static long absExact(long a)

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

С:

См. также:

abs(long)

abs

public static float abs(float a)

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

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

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

abs

public static double abs(double a)

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

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

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

max

public static int max(int a, int b)

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

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

max

public static long max(long a, long b)

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

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

max

public static float max(float a, float b)

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

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

fma

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

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

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

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

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

Примечание API:: Этот метод соответствует операции fusedMultiplyAdd, определённой в IEEE 754-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 (единица в последнем разряде) значения с плавающей запятой — это положительное расстояние между этим значением с плавающей запятой и ближайшим значением с плавающей запятой, следующим по величине. Обратите внимание, что для x, не равного NaN, 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)

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

Если аргумент 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)

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

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

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

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

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

cosh

public static double cosh(double x)

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

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

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

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

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

tanh

public static double tanh(double x)

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

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

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

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

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

hypot

public static double hypot(double x, double y)

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

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

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

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

Параметры:: x - значение; y - значение
Возвращает:: sqrt(x² +y²) без промежуточного переполнения или потери точности
С:: 1.5

expm1

public static double expm1(double x)

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

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

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

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

Параметры:: x - показатель степени, к которому нужно возвести e, в вычислении e^x -1.
Возвращает:: значение e^x - 1.
С:: 1.5

log1p

public static double log1p(double x)

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

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

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

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

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

copySign

public static double copySign(double magnitude, double sign)

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

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

copySign

public static float copySign(float magnitude, float sign)

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

getExponent

public static int getExponent(float f)

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

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

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

getExponent

public static int getExponent(double d)

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

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

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

nextAfter

public static double nextAfter(double start, double direction)

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

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

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

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

nextAfter

public static float nextAfter(float start, double direction)

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

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

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

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

nextUp

public static double nextUp(double d)

Возвращает значение с плавающей запятой, смежное с d в направлении положительной бесконечности. Этот метод семантически эквивалентен

nextAfter(d,
 Double.POSITIVE_INFINITY)

; однако, реализация nextUp может выполняться быстрее, чем эквивалентный вызов nextAfter.

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

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

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

nextUp

public static float nextUp(float f)

Возвращает значение с плавающей запятой, смежное с f в направлении положительной бесконечности. Этот метод семантически эквивалентен

nextAfter(f,
 Float.POSITIVE_INFINITY)

; однако, реализация nextUp может выполняться быстрее, чем эквивалентный вызов nextAfter.

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

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

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

nextDown

public static double nextDown(double d)

Возвращает значение с плавающей запятой, смежное с d в направлении отрицательной бесконечности. Этот метод семантически эквивалентен

nextAfter(d,
 Double.NEGATIVE_INFINITY)

; однако, реализация nextDown может выполняться быстрее, чем эквивалентный вызов nextAfter.

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

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

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

nextDown

public static float nextDown(float f)

Возвращает значение с плавающей запятой, смежное с f в направлении отрицательной бесконечности. Этот метод семантически эквивалентен

nextAfter(f,
 Float.NEGATIVE_INFINITY)

; однако, реализация nextDown может выполняться быстрее, чем эквивалентный вызов nextAfter.

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

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

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

scalb

public static double scalb(double d, int scaleFactor)

Возвращает d × 2^scaleFactor, округлённое так, как если бы оно выполнялось с помощью одного правильно округленного умножения чисел с плавающей запятой. Если порядок результата находится между Double.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.MIN_EXPONENT и Float.MAX_EXPONENT, ответ вычисляется точно. Если порядок результата будет больше


 Float.MAX_EXPONENT

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

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

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

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

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

© 1993, 2021, 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/17/docs/api/java.base/java/lang/Math.html

Класс Math

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

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

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

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

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

E

PI

Подробное описание методов

sin

cos

tan

asin

acos

atan

toRadians

toDegrees

exp

log

log10

sqrt

cbrt

IEEEremainder

ceil

floor

rint

atan2

pow

round

round

random

addExact

addExact

subtractExact

subtractExact

multiplyExact

multiplyExact

multiplyExact

incrementExact

incrementExact

decrementExact

decrementExact

negateExact

negateExact

toIntExact

multiplyFull

multiplyHigh

floorDiv

floorDiv

floorDiv

floorMod

floorMod

floorMod

abs

absExact

abs

absExact

abs

abs

max

max

max

max

min

min

min

min

fma

fma

ulp

ulp

signum

signum

sinh

cosh

tanh

hypot

expm1

log1p

copySign