Programming TIPS!

A site on Java API Examples and TIPS.
All Posts
Japanese Site

Java : Math with Examples

June 3, 2023 October 20, 2022

Math (Java SE 18 & JDK 18) API Examples.
You will find code examples on most Math methods.


Summary

The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

Math (Java SE 18 & JDK 18)

Class diagram

System.out.println(Math.sin(0.0)); // 0.0
System.out.println(Math.cos(0.0)); // 1.0

System.out.println(Math.absExact(123)); // 123
System.out.println(Math.absExact(-456)); // 456

System.out.println(Math.ceil(1.4)); // 2.0
System.out.println(Math.floor(1.6)); // 1.0

There is a StrictMath class which is similar to the Math class. The Math class permmits better-performing implementations where strict reproducibility is not required.


Fields

static final double E

The double value that is closer than any other to e, the base of the natural logarithms.

Math (Java SE 18 & JDK 18) 
// 2.718281828459045
System.out.println(Math.E);

static final double PI

The double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

Math (Java SE 18 & JDK 18) 
// 3.141592653589793
System.out.println(Math.PI);

Methods

static double abs (double a)

Returns the absolute value of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.abs(0.0)); // 0.0
System.out.println(Math.abs(1.23)); // 1.23
System.out.println(Math.abs(-4.56)); // 4.56

System.out.println(Math.abs(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.abs(Double.NEGATIVE_INFINITY)); // Infinity
System.out.println(Math.abs(Double.NaN)); // NaN

static float abs (float a)

Returns the absolute value of a float value.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to abs(double a).

static int abs (int a)

Returns the absolute value of an int value.

Math (Java SE 18 & JDK 18)

Please see also : absExact

System.out.println(Math.abs(0)); // 0
System.out.println(Math.abs(123)); // 123
System.out.println(Math.abs(-456)); // 456

System.out.println(Math.abs(Integer.MAX_VALUE)); // 2147483647

// The method may returns a negative value.
System.out.println(Math.abs(Integer.MIN_VALUE)); // -2147483648

static long abs (long a)

Returns the absolute value of a long value.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to abs(int a).

static int absExact (int a)

Returns the mathematical absolute value of an int value if it is exactly representable as an int, throwing ArithmeticException if the result overflows the positive int range.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.absExact(0)); // 0
System.out.println(Math.absExact(123)); // 123
System.out.println(Math.absExact(-456)); // 456

System.out.println(Math.absExact(Integer.MAX_VALUE)); // 2147483647

try {
    final var value = Math.absExact(Integer.MIN_VALUE);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//ArithmeticException!

static long absExact (long a)

Returns the mathematical absolute value of an long value if it is exactly representable as an long, throwing ArithmeticException if the result overflows the positive long range.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to absExact(int a).

static double acos (double a)

Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.acos(-1.0)); // 3.141592653589793 ( ≒ Math.PI )
System.out.println(Math.acos(0.0)); // 1.5707963267948966 ( ≒ Math.PI / 2 )
System.out.println(Math.acos(1.0)); // 0.0

System.out.println(Math.acos(Double.NaN)); // NaN

static int addExact (int x, int y)

Returns the sum of its arguments, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.addExact(1, 2)); // 3
System.out.println(Math.addExact(1000, 3000)); // 4000
System.out.println(Math.addExact(1000, -10000)); // -9000

try {
    System.out.println("MAX_VALUE : " + Integer.MAX_VALUE);
    final var value = Math.addExact(Integer.MAX_VALUE, 1);

} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MAX_VALUE : 2147483647
//ArithmeticException!

final int value = Integer.MAX_VALUE + 1;
System.out.println(value); // -2147483648

static long addExact (long x, long y)

Returns the sum of its arguments, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to addExact(int x, int y).

static double asin (double a)

Returns the arc sine of a value; the returned angle is in the range -pi/2 through pi/2.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.asin(-1.0)); // -1.5707963267948966 ( ≒ -Math.PI / 2 )
System.out.println(Math.asin(0.0)); // 0.0
System.out.println(Math.asin(1.0)); // 1.5707963267948966 ( ≒ Math.PI / 2 )

System.out.println(Math.asin(Double.NaN)); // NaN

static double atan (double a)

Returns the arc tangent of a value; the returned angle is in the range -pi/2 through pi/2.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.atan(Double.NEGATIVE_INFINITY)); // -1.5707963267948966 ( ≒ -Math.PI / 2 )
System.out.println(Math.atan(-1.0)); // -0.7853981633974483 ( ≒ -Math.PI / 4 )
System.out.println(Math.atan(0.0)); // 0.0
System.out.println(Math.atan(1.0)); // 0.7853981633974483 ( ≒ Math.PI / 4 )
System.out.println(Math.atan(Double.POSITIVE_INFINITY)); // 1.5707963267948966 ( ≒ Math.PI / 2 )

System.out.println(Math.atan(Double.NaN)); // NaN

static double atan2 (double y, double x)

Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta).

Math (Java SE 18 & JDK 18) 
System.out.println(Math.atan2(0.0, -1.0)); // 3.141592653589793 ( ≒ Math.PI )
System.out.println(Math.atan2(1.0, 0.0)); // 1.5707963267948966 ( ≒ Math.PI / 2 )
System.out.println(Math.atan2(0.0, 1.0)); // 0.0
System.out.println(Math.atan2(-1.0, 0.0)); // -1.5707963267948966 ( ≒ -Math.PI / 2 )

static double cbrt (double a)

Returns the cube root of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.cbrt(0.0)); // 0.0
System.out.println(Math.cbrt(1.0)); // 1.0
System.out.println(Math.cbrt(8.0)); // 2.0
System.out.println(Math.cbrt(-27.0)); // -3.0

System.out.println(Math.cbrt(-0.0)); // -0.0
System.out.println(Math.cbrt(Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.cbrt(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.cbrt(Double.NaN)); // NaN

static double ceil (double a)

Returns the smallest (closest to negative infinity) double value that is greater than or equal to the argument and is equal to a mathematical integer.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.ceil(0.0)); // 0.0
System.out.println(Math.ceil(1.2)); // 2.0
System.out.println(Math.ceil(1.8)); // 2.0
System.out.println(Math.ceil(-3.12)); // -3.0
System.out.println(Math.ceil(-3.89)); // -3.0

System.out.println(Math.ceil(-0.0)); // -0.0
System.out.println(Math.ceil(Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.ceil(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.ceil(Double.NaN)); // NaN

static int ceilDiv (int x, int y)

Returns the smallest (closest to negative infinity) int value that is greater than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

Please see also : ceilDivExact(int x, int y)

System.out.println(Math.ceilDiv(4, 3)); // 2
System.out.println(4 / 3); // 1

System.out.println(Math.ceilDiv(-4, 3)); // -1
System.out.println(-4 / 3); // -1

System.out.println(Math.ceilDiv(Integer.MIN_VALUE, -1) == Integer.MIN_VALUE); // true

static long ceilDiv (long x, int y)

Returns the smallest (closest to negative infinity) long value that is greater than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ceilDiv(int x, int y).

static long ceilDiv (long x, long y)

Returns the smallest (closest to negative infinity) long value that is greater than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ceilDiv(int x, int y).

static int ceilDivExact (int x, int y)

Returns the smallest (closest to negative infinity) int value that is greater than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

Please see also : ceilDiv(int x, int y)

System.out.println(Math.ceilDivExact(4, 3)); // 2
System.out.println(4 / 3); // 1

System.out.println(Math.ceilDivExact(-4, 3)); // -1
System.out.println(-4 / 3); // -1

try {
    final var value = Math.ceilDivExact(Integer.MIN_VALUE, -1);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//ArithmeticException!

static long ceilDivExact (long x, long y)

Returns the smallest (closest to negative infinity) long value that is greater than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ceilDivExact(int x, int y).

static int ceilMod (int x, int y)

Returns the ceiling modulus of the int arguments.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.ceilMod(4, 3)); // -2
System.out.println(4 % 3); // 1

System.out.println(Math.ceilMod(-4, 3)); // -1
System.out.println(-4 % 3); // -1

System.out.println(Math.ceilMod(4, -3)); // 1
System.out.println(4 % -3); // 1

System.out.println(Math.ceilMod(-4, -3)); // 2
System.out.println(-4 % -3); // -1

static int ceilMod (long x, int y)

Returns the ceiling modulus of the long and int arguments.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ceilMod(int x, int y).

static long ceilMod (long x, long y)

Returns the ceiling modulus of the long arguments.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ceilMod(int x, int y).

static double copySign (double magnitude, double sign)

Returns the first floating-point argument with the sign of the second floating-point argument.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.copySign(1.23, 4.56)); // 1.23
System.out.println(Math.copySign(1.23, -4.56)); // -1.23
System.out.println(Math.copySign(-7.89, 1.23)); // 7.89
System.out.println(Math.copySign(-7.89, -1.23)); // -7.89

System.out.println(Math.copySign(0.0, 0.0)); // 0.0
System.out.println(Math.copySign(0.0, -0.0)); // -0.0
System.out.println(Math.copySign(1.0, Double.NEGATIVE_INFINITY)); // -1.0
System.out.println(Math.copySign(1.0, Double.POSITIVE_INFINITY)); // 1.0
System.out.println(Math.copySign(1.0, Double.NaN)); // 1.0

static float copySign (float magnitude, float sign)

Returns the first floating-point argument with the sign of the second floating-point argument.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to copySign(double magnitude, double sign).

static double cos (double a)

Returns the trigonometric cosine of an angle.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.cos(-Math.PI)); // -1.0
System.out.println(Math.cos(-Math.PI * 0.75)); // -0.7071067811865475
System.out.println(Math.cos(-Math.PI * 0.5)); // 6.123233995736766E-17 (≒ 0.0)
System.out.println(Math.cos(-Math.PI * 0.25)); // 0.7071067811865476
System.out.println(Math.cos(0.0)); // 1.0
System.out.println(Math.cos(Math.PI * 0.25)); // 0.7071067811865476
System.out.println(Math.cos(Math.PI * 0.5)); // 6.123233995736766E-17 (≒ 0.0)
System.out.println(Math.cos(Math.PI * 0.75)); // -0.7071067811865475
System.out.println(Math.cos(Math.PI)); // -1.0

System.out.println(Math.cos(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.cos(Double.POSITIVE_INFINITY)); // NaN
System.out.println(Math.cos(Double.NaN)); // NaN

static double cosh (double x)

Returns the hyperbolic cosine of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.cosh(-1.0)); // 1.543080634815244
System.out.println(Math.cosh(-0.5)); // 1.1276259652063807
System.out.println(Math.cosh(0.0)); // 1.0
System.out.println(Math.cosh(0.5)); // 1.543080634815244
System.out.println(Math.cosh(1.0)); // -1.0

System.out.println(Math.cosh(Double.NEGATIVE_INFINITY)); // Infinity
System.out.println(Math.cosh(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.cosh(Double.NaN)); // NaN

static int decrementExact (int a)

Returns the argument decremented by one, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.decrementExact(Integer.MAX_VALUE)); // 2147483646
System.out.println(Math.decrementExact(100)); // 99
System.out.println(Math.decrementExact(1)); // 0
System.out.println(Math.decrementExact(0)); // -1
System.out.println(Math.decrementExact(-100)); // -101

try {
    System.out.println("MIN_VALUE : " + Integer.MIN_VALUE);
    final int value = Math.decrementExact(Integer.MIN_VALUE);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MIN_VALUE : -2147483648
//ArithmeticException!

final int value = Integer.MIN_VALUE - 1;
System.out.println(value); // 2147483647

static long decrementExact (long a)

Returns the argument decremented by one, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to decrementExact(int a).

static int divideExact (int x, int y)

Returns the quotient of the arguments, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.divideExact(100, 2)); // 50
System.out.println(Math.divideExact(10, 3)); // 3

System.out.println(Math.divideExact(-500, 10)); // -50
System.out.println(Math.divideExact(-1000, -500)); // 2

try {
    System.out.println("MIN_VALUE : " + Integer.MIN_VALUE);
    final int value = Math.divideExact(Integer.MIN_VALUE, -1);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MIN_VALUE : -2147483648
//ArithmeticException!

static long divideExact (long x, long y)

Returns the quotient of the arguments, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to divideExact(int x, int y).

static double exp (double a)

Returns Euler's number e raised to the power of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.exp(-2.0)); // 0.1353352832366127
System.out.println(Math.exp(-1.0)); // 0.36787944117144233
System.out.println(Math.exp(0.0)); // 1.0
System.out.println(Math.exp(1.0)); // 2.718281828459045
System.out.println(Math.exp(2.0)); // 7.38905609893065

System.out.println(Math.exp(Double.NEGATIVE_INFINITY)); // 0.0
System.out.println(Math.exp(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.exp(Double.NaN)); // NaN

static double expm1 (double x)

Returns ex -1.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.expm1(-2.0)); // -0.8646647167633873
System.out.println(Math.expm1(-1.0)); // -0.6321205588285577
System.out.println(Math.expm1(0.0)); // 0.0
System.out.println(Math.expm1(1.0)); // 1.718281828459045
System.out.println(Math.expm1(2.0)); // 6.38905609893065

System.out.println(Math.expm1(Double.NEGATIVE_INFINITY)); // -1.0
System.out.println(Math.expm1(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.expm1(Double.NaN)); // NaN

static double floor (double a)

Returns the largest (closest to positive infinity) double value that is less than or equal to the argument and is equal to a mathematical integer.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.floor(1.2)); // 1.0
System.out.println(Math.floor(1.8)); // 1.0
System.out.println(Math.floor(2.3)); // 2.0
System.out.println(Math.floor(2.9)); // 2.0
System.out.println(Math.floor(-3.12)); // -4.0
System.out.println(Math.floor(-3.89)); // -4.0

System.out.println(Math.floor(0.0)); // 0.0
System.out.println(Math.floor(-0.0)); // -0.0

System.out.println(Math.floor(Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.floor(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.floor(Double.NaN)); // NaN

static int floorDiv (int x, int y)

Returns the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

Please see also : floorDivExact(int x, int y)

System.out.println(Math.floorDiv(10, 1)); // 10
System.out.println(Math.floorDiv(10, 2)); // 5
System.out.println(Math.floorDiv(10, 3)); // 3
System.out.println(Math.floorDiv(10, 4)); // 2
System.out.println(Math.floorDiv(10, 5)); // 2
System.out.println(Math.floorDiv(10, 6)); // 1

System.out.println(Math.floorDiv(10, 10)); // 1
System.out.println(Math.floorDiv(10, 11)); // 0

System.out.println(Math.floorDiv(10, -1)); // -10
System.out.println(Math.floorDiv(10, -2)); // -5
System.out.println(Math.floorDiv(10, -3)); // -4
System.out.println(Math.floorDiv(10, -4)); // -3
System.out.println(Math.floorDiv(10, -5)); // -2
System.out.println(Math.floorDiv(10, -6)); // -2

System.out.println(Math.floorDiv(10, -10)); // -1
System.out.println(Math.floorDiv(10, -11)); // -1

System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Math.floorDiv(Integer.MIN_VALUE, -1)); // -2147483648

static long floorDiv (long x, int y)

Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to floorDiv(int x, int y).

static long floorDiv (long x, long y)

Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to floorDiv(int x, int y).

static int floorDivExact (int x, int y)

Returns the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

Please see also : floorDiv(int x, int y)

System.out.println(Math.floorDivExact(10, 1)); // 10
System.out.println(Math.floorDivExact(10, 2)); // 5
System.out.println(Math.floorDivExact(10, 3)); // 3

System.out.println(Math.floorDivExact(10, -1)); // -10
System.out.println(Math.floorDivExact(10, -2)); // -5
System.out.println(Math.floorDivExact(10, -3)); // -4

try {
    System.out.println("MIN_VALUE : " + Integer.MIN_VALUE);
    final var value = Math.floorDivExact(Integer.MIN_VALUE, -1);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MIN_VALUE : -2147483648
//ArithmeticException!

static long floorDivExact (long x, long y)

Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to floorDivExact(int x, int y).

static int floorMod (int x, int y)

Returns the floor modulus of the int arguments.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.floorMod(10, 1)); // 0
System.out.println(Math.floorMod(10, 2)); // 0
System.out.println(Math.floorMod(10, 3)); // 1
System.out.println(Math.floorMod(10, 4)); // 2
System.out.println(Math.floorMod(10, 5)); // 0
System.out.println(Math.floorMod(10, 6)); // 4
System.out.println(Math.floorMod(10, 7)); // 3

System.out.println(Math.floorMod(10, 10)); // 0
System.out.println(Math.floorMod(10, 11)); // 10

System.out.println(Math.floorMod(10, -1)); // 0
System.out.println(Math.floorMod(10, -2)); // 0
System.out.println(Math.floorMod(10, -3)); // -2
System.out.println(Math.floorMod(10, -4)); // -2
System.out.println(Math.floorMod(10, -5)); // 0
System.out.println(Math.floorMod(10, -6)); // -2
System.out.println(Math.floorMod(10, -7)); // -4

System.out.println(Math.floorMod(10, -10)); // 0
System.out.println(Math.floorMod(10, -11)); // -1

System.out.println(Math.floorMod(-10, 1)); // 0
System.out.println(Math.floorMod(-10, 2)); // 0
System.out.println(Math.floorMod(-10, 3)); // 2
System.out.println(Math.floorMod(-10, 4)); // 2
System.out.println(Math.floorMod(-10, 5)); // 0
System.out.println(Math.floorMod(-10, 6)); // 2
System.out.println(Math.floorMod(-10, 7)); // 4

System.out.println(Math.floorMod(-10, 10)); // 0
System.out.println(Math.floorMod(-10, 11)); // 1

static int floorMod (long x, int y)

Returns the floor modulus of the long and int arguments.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to floorMod(int x, int y).

static long floorMod (long x, long y)

Returns the floor modulus of the long arguments.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to floorMod(int x, int y).

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

Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest double.

Math (Java SE 18 & JDK 18) 
final double a = 0.6;
final double b = 3.0;
final double c = 0.9;

System.out.println(Math.fma(a, b, c)); // 2.7
System.out.println(a * b + c); // 2.6999999999999997

System.out.println(Math.fma(Double.NaN, 1.0, 2.0)); // NaN
System.out.println(Math.fma(Double.POSITIVE_INFINITY, 0.0, 2.0)); // NaN
System.out.println(Math.fma(Double.POSITIVE_INFINITY, 1.0, Double.NEGATIVE_INFINITY)); // NaN

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

Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest float.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to fma(double a, double b, double c).

static int getExponent (double d)

Returns the unbiased exponent used in the representation of a double.

Math (Java SE 18 & JDK 18) 
final double value1 = 0x1.0p1;
System.out.println(value1); // 2.0
System.out.println(Math.getExponent(value1)); // 1

final double value2 = 0x1.0p2;
System.out.println(value2); // 4.0
System.out.println(Math.getExponent(value2)); // 2

final double value3 = 0x1.0p3;
System.out.println(value3); // 8.0
System.out.println(Math.getExponent(value3)); // 3

System.out.println(Double.MAX_EXPONENT); // 1023
System.out.println(Math.getExponent(Double.NaN)); // 1024
System.out.println(Math.getExponent(Double.POSITIVE_INFINITY)); // 1024
System.out.println(Math.getExponent(Double.NEGATIVE_INFINITY)); // 1024

System.out.println(Double.MIN_EXPONENT); // -1022
System.out.println(Math.getExponent(0.0)); // -1023

static int getExponent (float f)

Returns the unbiased exponent used in the representation of a float.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to getExponent(double d).

static double hypot (double x, double y)

Returns sqrt(x2 +y2) without intermediate overflow or underflow.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.hypot(1.0, 0.0)); // 1.0
System.out.println(Math.hypot(3.0, 4.0)); // 5.0

final double x = Double.MAX_VALUE;
final double y = Double.MIN_VALUE;

System.out.println(Math.hypot(x, y)); // 1.7976931348623157E308
System.out.println(Math.sqrt((x * x) + (y * y))); // Infinity

System.out.println(Math.hypot(Double.NEGATIVE_INFINITY, 1.0)); // Infinity
System.out.println(Math.hypot(Double.POSITIVE_INFINITY, 1.0)); // Infinity
System.out.println(Math.hypot(Double.NaN, 1.0)); // NaN

static double IEEEremainder (double f1, double f2)

Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.IEEEremainder(10.0, 1.0)); // 0.0
System.out.println(Math.IEEEremainder(10.0, 2.0)); // 0.0
System.out.println(Math.IEEEremainder(10.0, 3.0)); // 1.0
System.out.println(Math.IEEEremainder(10.0, 4.0)); // 2.0
System.out.println(Math.IEEEremainder(10.0, 5.0)); // 0.0
System.out.println(Math.IEEEremainder(10.0, 6.0)); // -2.0
System.out.println(Math.IEEEremainder(10.0, 7.0)); // 3.0
System.out.println(Math.IEEEremainder(10.0, 8.0)); // 2.0
System.out.println(Math.IEEEremainder(10.0, 9.0)); // 1.0
System.out.println(Math.IEEEremainder(10.0, 10.0)); // 0.0
System.out.println(Math.IEEEremainder(10.0, 11.0)); // -1.0

System.out.println(10.0 % 1.0); // 0.0
System.out.println(10.0 % 2.0); // 0.0
System.out.println(10.0 % 3.0); // 1.0
System.out.println(10.0 % 4.0); // 2.0
System.out.println(10.0 % 5.0); // 0.0
System.out.println(10.0 % 6.0); // 4.0
System.out.println(10.0 % 7.0); // 3.0
System.out.println(10.0 % 8.0); // 2.0
System.out.println(10.0 % 9.0); // 1.0
System.out.println(10.0 % 10.0); // 0.0
System.out.println(10.0 % 11.0); // 10.0

System.out.println(Math.IEEEremainder(10.0, 0.0)); // NaN
System.out.println(Math.IEEEremainder(Double.POSITIVE_INFINITY, 1.0)); // NaN
System.out.println(Math.IEEEremainder(Double.NEGATIVE_INFINITY, 1.0)); // NaN
System.out.println(Math.IEEEremainder(Double.NaN, 1.0)); // NaN

System.out.println(Math.IEEEremainder(2.0, Double.POSITIVE_INFINITY)); // 2.0
System.out.println(Math.IEEEremainder(2.0, Double.NEGATIVE_INFINITY)); // 2.0

static int incrementExact (int a)

Returns the argument incremented by one, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.incrementExact(0)); // 1
System.out.println(Math.incrementExact(1)); // 2
System.out.println(Math.incrementExact(1000)); // 1001
System.out.println(Math.incrementExact(-1000)); // -999

try {
    System.out.println("MAX_VALUE : " + Integer.MAX_VALUE);
    final var value = Math.incrementExact(Integer.MAX_VALUE);

} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MAX_VALUE : 2147483647
//ArithmeticException!

final int value = Integer.MAX_VALUE + 1;
System.out.println(value); // -2147483648

static long incrementExact (long a)

Returns the argument incremented by one, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to incrementExact(int a).

static double log (double a)

Returns the natural logarithm (base e) of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.log(0.1)); // -2.3025850929940455
System.out.println(Math.log(0.2)); // -1.6094379124341003
System.out.println(Math.log(0.3)); // -1.2039728043259361
System.out.println(Math.log(0.4)); // -0.916290731874155
System.out.println(Math.log(0.5)); // -0.6931471805599453

System.out.println(Math.log(1.0)); // 0.0
System.out.println(Math.log(2.0)); // 0.6931471805599453
System.out.println(Math.log(3.0)); // 1.0986122886681098
System.out.println(Math.log(4.0)); // 1.3862943611198906
System.out.println(Math.log(5.0)); // 1.6094379124341003

System.out.println(Math.log(-1.0)); // NaN
System.out.println(Math.log(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.log(Double.NaN)); // NaN

System.out.println(Math.log(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.log(0.0)); // -Infinity

static double log10 (double a)

Returns the base 10 logarithm of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.log10(0.1)); // -1.0
System.out.println(Math.log10(0.2)); // -0.6989700043360187
System.out.println(Math.log10(0.3)); // -0.5228787452803376
System.out.println(Math.log10(0.4)); // -0.3979400086720376
System.out.println(Math.log10(0.5)); // -0.3010299956639812

System.out.println(Math.log10(1.0)); // 0.0
System.out.println(Math.log10(2.0)); // 0.3010299956639812
System.out.println(Math.log10(3.0)); // 0.47712125471966244
System.out.println(Math.log10(4.0)); // 0.6020599913279624
System.out.println(Math.log10(5.0)); // 0.6989700043360189

System.out.println(Math.log10(10.0)); // 1.0
System.out.println(Math.log10(100.0)); // 2.0
System.out.println(Math.log10(1000.0)); // 3.0

System.out.println(Math.log10(-1.0)); // NaN
System.out.println(Math.log10(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.log10(Double.NaN)); // NaN

System.out.println(Math.log10(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.log10(0.0)); // -Infinity

static double log1p (double x)

Returns the natural logarithm of the sum of the argument and 1.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.log1p(-0.9)); // -2.302585092994046
System.out.println(Math.log1p(-0.8)); // -1.6094379124341005
System.out.println(Math.log1p(-0.7)); // -1.203972804325936
System.out.println(Math.log1p(-0.6)); // -0.916290731874155
System.out.println(Math.log1p(-0.5)); // -0.6931471805599453

System.out.println(Math.log1p(0.0)); // 0.0
System.out.println(Math.log1p(1.0)); // 0.6931471805599453
System.out.println(Math.log1p(2.0)); // 1.0986122886681096
System.out.println(Math.log1p(3.0)); // 1.3862943611198906
System.out.println(Math.log1p(4.0)); // 1.6094379124341003

System.out.println(Math.log1p(-2.0)); // NaN
System.out.println(Math.log1p(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.log1p(Double.NaN)); // NaN

System.out.println(Math.log1p(Double.POSITIVE_INFINITY)); // Infinity

static double max (double a, double b)

Returns the greater of two double values.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.max(1.0, 2.0)); // 2.0
System.out.println(Math.max(2.0, 1.0)); // 2.0

System.out.println(Math.max(5.0, 5.0)); // 5.0
System.out.println(Math.max(+0.0, -0.0)); // 0.0

System.out.println(Math.max(Double.MAX_VALUE, Double.MIN_VALUE)); // 1.7976931348623157E308
System.out.println(Math.max(999.0, Double.NEGATIVE_INFINITY)); // 999.0
System.out.println(Math.max(999.0, Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.max(999.0, Double.NaN)); // NaN

static float max (float a, float b)

Returns the greater of two float values.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to max(double a, double b).

static int max (int a, int b)

Returns the greater of two int values.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.max(1, 2)); // 2
System.out.println(Math.max(2, 1)); // 2

System.out.println(Math.max(5, 5)); // 5
System.out.println(Math.max(+0, -0)); // 0

System.out.println(Math.max(Integer.MAX_VALUE, Integer.MIN_VALUE)); // 2147483647

static long max (long a, long b)

Returns the greater of two long values.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to max(int a, int b).

static double min (double a, double b)

Returns the smaller of two double values.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.min(1.0, 2.0)); // 1.0
System.out.println(Math.min(2.0, 1.0)); // 1.0

System.out.println(Math.min(5.0, 5.0)); // 5.0
System.out.println(Math.min(+0.0, -0.0)); // -0.0

System.out.println(Math.min(Double.MAX_VALUE, Double.MIN_VALUE)); // 4.9E-324
System.out.println(Math.min(999.0, Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.min(999.0, Double.POSITIVE_INFINITY)); // 999.0
System.out.println(Math.min(999.0, Double.NaN)); // NaN

static float min (float a, float b)

Returns the smaller of two float values.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to min(double a, double b).

static int min (int a, int b)

Returns the smaller of two int values.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.min(1, 2)); // 1
System.out.println(Math.min(2, 1)); // 1

System.out.println(Math.min(5, 5)); // 5
System.out.println(Math.min(+0, -0)); // 0

System.out.println(Math.min(Integer.MAX_VALUE, Integer.MIN_VALUE)); // -2147483648

static long min (long a, long b)

Returns the smaller of two long values.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to min(int a, int b).

static int multiplyExact (int x, int y)

Returns the product of the arguments, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.multiplyExact(0, 100)); // 0
System.out.println(Math.multiplyExact(1, 300)); // 300
System.out.println(Math.multiplyExact(5000, 100)); // 500000
System.out.println(Math.multiplyExact(5000, -100)); // -500000

try {
    final var value = Math.multiplyExact(1000000, 1000000);

} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//ArithmeticException!

final int value = 1000000 * 1000000;
System.out.println(value); // -727379968

static long multiplyExact (long x, int y)

Returns the product of the arguments, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to multiplyExact(int x, int y).

static long multiplyExact (long x, long y)

Returns the product of the arguments, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to multiplyExact(int x, int y).

static long multiplyFull (int x, int y)

Returns the exact mathematical product of the arguments.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.multiplyFull(0, 100)); // 0
System.out.println(Math.multiplyFull(1, 300)); // 300
System.out.println(Math.multiplyFull(5000, 100)); // 500000
System.out.println(Math.multiplyFull(5000, -100)); // -500000
System.out.println(Math.multiplyFull(1000000, 1000000)); // 1000000000000
System.out.println(Math.multiplyFull(Integer.MAX_VALUE, Integer.MAX_VALUE)); // 4611686014132420609
System.out.println(Math.multiplyFull(Integer.MIN_VALUE, Integer.MIN_VALUE)); // 4611686018427387904

static long multiplyHigh (long x, long y)

Returns as a long the most significant 64 bits of the 128-bit product of two 64-bit factors.

Math (Java SE 18 & JDK 18)

Please see also : unsignedMultiplyHigh(long x, long y)

final var x = 0x1234567890abcdefL;

System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x0L)); // 0x0
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x1L)); // 0x0
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x10L)); // 0x1
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x100L)); // 0x12
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x1000L)); // 0x123
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x10000L)); // 0x1234
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x100000L)); // 0x12345
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x1000000L)); // 0x123456
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x10000000L)); // 0x1234567
System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x100000000L)); // 0x12345678

static int negateExact (int a)

Returns the negation of the argument, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.negateExact(Integer.MAX_VALUE)); // -2147483647
System.out.println(Math.negateExact(100)); // -100
System.out.println(Math.negateExact(1)); // -1
System.out.println(Math.negateExact(0)); // 0
System.out.println(Math.negateExact(-100)); // 100

try {
    final int value = Math.negateExact(Integer.MIN_VALUE);
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException! : " + e.getMessage());
}

// Result
// ↓
//ArithmeticException! : integer overflow

static long negateExact (long a)

Returns the negation of the argument, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to negateExact(int a).

static double nextAfter (double start, double direction)

Returns the floating-point number adjacent to the first argument in the direction of the second argument.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.nextAfter(1.0, 2.0)); // 1.0000000000000002
System.out.println(Math.nextAfter(1.0000000000000001, 2.0)); // 1.0000000000000002
System.out.println(Math.nextAfter(1.0000000000000002, 2.0)); // 1.0000000000000004
System.out.println(Math.nextAfter(1.0000000000000003, 2.0)); // 1.0000000000000004

System.out.println(Math.nextAfter(1.0, -2.0)); // 0.9999999999999999
System.out.println(Math.nextAfter(0.9999999999999999, -2.0)); // 0.9999999999999998
System.out.println(Math.nextAfter(0.9999999999999998, -2.0)); // 0.9999999999999997

System.out.println(Math.nextAfter(1.0, 1.0)); // 1.0

System.out.println(Math.nextAfter(1.0, Double.NaN)); // NaN
System.out.println(Math.nextAfter(Double.MIN_VALUE, -1.0)); // 0.0

// 1.7976931348623157E308 ( = Double.MAX_VALUE)
System.out.println(Math.nextAfter(Double.POSITIVE_INFINITY, -1.0));

static float nextAfter (float start, double direction)

Returns the floating-point number adjacent to the first argument in the direction of the second argument.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to nextAfter(double start, double direction).

static double nextDown (double d)

Returns the floating-point value adjacent to d in the direction of negative infinity.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.nextDown(1.0)); // 0.9999999999999999
System.out.println(Math.nextDown(0.9999999999999999)); // 0.9999999999999998
System.out.println(Math.nextDown(0.9999999999999998)); // 0.9999999999999997

System.out.println(Math.nextDown(Double.NaN)); // NaN
System.out.println(Math.nextDown(Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.nextDown(0.0)); // -4.9E-324 ( = -Double.MIN_VALUE )

static float nextDown (float f)

Returns the floating-point value adjacent to f in the direction of negative infinity.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to nextDown(double d).

static double nextUp (double d)

Returns the floating-point value adjacent to d in the direction of positive infinity.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.nextUp(1.0)); // 1.0000000000000002
System.out.println(Math.nextUp(1.0000000000000001)); // 1.0000000000000002
System.out.println(Math.nextUp(1.0000000000000002)); // 1.0000000000000004
System.out.println(Math.nextUp(1.0000000000000003)); // 1.0000000000000004

System.out.println(Math.nextUp(Double.NaN)); // NaN
System.out.println(Math.nextUp(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.nextUp(0.0)); // 4.9E-324 ( = Double.MIN_VALUE )

static float nextUp (float f)

Returns the floating-point value adjacent to f in the direction of positive infinity.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to nextUp(double d).

static double pow (double a, double b)

Returns the value of the first argument raised to the power of the second argument.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.pow(2.0, 0.0)); // 1.0
System.out.println(Math.pow(2.0, 1.0)); // 2.0
System.out.println(Math.pow(2.0, 2.0)); // 4.0
System.out.println(Math.pow(2.0, 3.0)); // 8.0
System.out.println(Math.pow(2.0, 4.0)); // 16.0

System.out.println(Math.pow(2.0, -1.0)); // 0.5
System.out.println(Math.pow(2.0, -2.0)); // 0.25
System.out.println(Math.pow(2.0, -3.0)); // 0.125
System.out.println(Math.pow(2.0, -4.0)); // 0.0625

System.out.println(Math.pow(2.0, Double.NaN)); // NaN
System.out.println(Math.pow(Double.NaN, 2.0)); // NaN

System.out.println(Math.pow(2.0, Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.pow(0.5, Double.NEGATIVE_INFINITY)); // Infinity

System.out.println(Math.pow(2.0, Double.NEGATIVE_INFINITY)); // 0.0
System.out.println(Math.pow(0.5, Double.POSITIVE_INFINITY)); // 0.0

System.out.println(Math.pow(0.0, 2.0)); // 0.0
System.out.println(Math.pow(Double.POSITIVE_INFINITY, -2.0)); // 0.0

System.out.println(Math.pow(0.0, -2.0)); // Infinity
System.out.println(Math.pow(Double.POSITIVE_INFINITY, 2.0)); // Infinity

static double random ()

Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0.

Math (Java SE 18 & JDK 18)

Please see also : Random , RandomGenerator

System.out.println(Math.random()); // 0.2637632679380906
System.out.println(Math.random()); // 0.43028303277317403
System.out.println(Math.random()); // 0.5014048102036631
System.out.println(Math.random()); // 0.8983305345177616
System.out.println(Math.random()); // 0.05255565620878788

static double rint (double a)

Returns the double value that is closest in value to the argument and is equal to a mathematical integer.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.rint(0.0)); // 0.0
System.out.println(Math.rint(0.1)); // 0.0
System.out.println(Math.rint(0.2)); // 0.0

System.out.println(Math.rint(0.4)); // 0.0
System.out.println(Math.rint(0.5)); // 0.0
System.out.println(Math.rint(0.51)); // 1.0

System.out.println(Math.rint(0.6)); // 1.0

System.out.println(Math.rint(0.9)); // 1.0
System.out.println(Math.rint(1.1)); // 1.0
System.out.println(Math.rint(1.2)); // 1.0

System.out.println(Math.rint(1.4)); // 1.0
System.out.println(Math.rint(1.5)); // 2.0
System.out.println(Math.rint(1.6)); // 2.0

System.out.println(Math.rint(-99.4)); // -99.0
System.out.println(Math.rint(-99.5)); // -100.0
System.out.println(Math.rint(-99.6)); // -100.0

System.out.println(Math.rint(Double.NaN)); // NaN
System.out.println(Math.rint(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.rint(Double.NEGATIVE_INFINITY)); // -Infinity

static long round (double a)

Returns the closest long to the argument, with ties rounding to positive infinity.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.round(0.0)); // 0
System.out.println(Math.round(0.1)); // 0
System.out.println(Math.round(0.2)); // 0

System.out.println(Math.round(0.4)); // 0
System.out.println(Math.round(0.5)); // 1
System.out.println(Math.round(0.6)); // 1

System.out.println(Math.round(0.9)); // 1
System.out.println(Math.round(1.1)); // 1
System.out.println(Math.round(1.2)); // 1

System.out.println(Math.round(1.4)); // 1
System.out.println(Math.round(1.5)); // 2
System.out.println(Math.round(1.6)); // 2

System.out.println(Math.round(-99.4)); // -99
System.out.println(Math.round(-99.5)); // -99
System.out.println(Math.round(-99.6)); // -100

System.out.println(Math.round(Double.NaN)); // NaN

// 9223372036854775807 ( = Long.MAX_VALUE )
System.out.println(Math.round(Double.POSITIVE_INFINITY));

// -9223372036854775808 ( = Long.MIN_VALUE )
System.out.println(Math.round(Double.NEGATIVE_INFINITY));

static int round (float a)

Returns the closest int to the argument, with ties rounding to positive infinity.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to round(double a).

static double scalb (double d, int scaleFactor)

Returns d × 2scaleFactor rounded as if performed by a single correctly rounded floating-point multiply.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.scalb(2.0, 0)); // 2.0
System.out.println(Math.scalb(2.0, 1)); // 4.0
System.out.println(Math.scalb(2.0, 2)); // 8.0
System.out.println(Math.scalb(2.0, 3)); // 16.0
System.out.println(Math.scalb(2.0, 4)); // 32.0

System.out.println(Math.scalb(2.0, -1)); // 1.0
System.out.println(Math.scalb(2.0, -2)); // 0.5
System.out.println(Math.scalb(2.0, -3)); // 0.25
System.out.println(Math.scalb(2.0, -4)); // 0.125

System.out.println(Math.scalb(Double.NaN, 1)); // NaN
System.out.println(Math.scalb(Double.POSITIVE_INFINITY, 1)); // Infinity
System.out.println(Math.scalb(Double.NEGATIVE_INFINITY, 1)); // -Infinity
System.out.println(Math.scalb(0.0, 100)); // 0.0

static float scalb (float f, int scaleFactor)

Returns f × 2scaleFactor rounded as if performed by a single correctly rounded floating-point multiply.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to scalb(double d, int scaleFactor).

static double signum (double d)

Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.signum(2.0)); // 1.0
System.out.println(Math.signum(-2.0)); // -1.0

System.out.println(Math.signum(100.0)); // 1.0
System.out.println(Math.signum(-100.0)); // -1.0

System.out.println(Math.signum(0.0)); // 0.0
System.out.println(Math.signum(-0.0)); // -0.0

System.out.println(Math.signum(Double.NaN)); // NaN
System.out.println(Math.signum(Double.POSITIVE_INFINITY)); // 1.0
System.out.println(Math.signum(Double.NEGATIVE_INFINITY)); // -1.0

static float signum (float f)

Returns the signum function of the argument; zero if the argument is zero, 1.0f if the argument is greater than zero, -1.0f if the argument is less than zero.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to signum(double d).

static double sin (double a)

Returns the trigonometric sine of an angle.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.sin(-Math.PI)); // -1.2246467991473532E-16 (≒ 0.0)
System.out.println(Math.sin(-Math.PI * 0.75)); // -0.7071067811865476
System.out.println(Math.sin(-Math.PI * 0.5)); // -1.0
System.out.println(Math.sin(-Math.PI * 0.25)); // -0.7071067811865475
System.out.println(Math.sin(0.0)); // 0.0
System.out.println(Math.sin(Math.PI * 0.25)); // 0.7071067811865475
System.out.println(Math.sin(Math.PI * 0.5)); // 1.0
System.out.println(Math.sin(Math.PI * 0.75)); // 0.7071067811865476
System.out.println(Math.sin(Math.PI)); // 1.2246467991473532E-16 (≒ 0.0)

System.out.println(Math.sin(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.sin(Double.POSITIVE_INFINITY)); // NaN
System.out.println(Math.sin(Double.NaN)); // NaN

static double sinh (double x)

Returns the hyperbolic sine of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.sinh(-1.0)); // -1.1752011936438014
System.out.println(Math.sinh(-0.5)); // -0.5210953054937474
System.out.println(Math.sinh(0.0)); // 0.0
System.out.println(Math.sinh(0.5)); // 0.5210953054937474
System.out.println(Math.sinh(1.0)); // 1.1752011936438014

System.out.println(Math.sinh(Double.NEGATIVE_INFINITY)); // -Infinity
System.out.println(Math.sinh(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.sinh(Double.NaN)); // NaN

static double sqrt (double a)

Returns the correctly rounded positive square root of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.sqrt(0.0)); // 0.0
System.out.println(Math.sqrt(1.0)); // 1.0
System.out.println(Math.sqrt(2.0)); // 1.4142135623730951

System.out.println(Math.sqrt(4.0)); // 2.0
System.out.println(Math.sqrt(9.0)); // 3.0
System.out.println(Math.sqrt(16.0)); // 4.0
System.out.println(Math.sqrt(25.0)); // 5.0

System.out.println(Math.sqrt(-1.0)); // NaN
System.out.println(Math.sqrt(Double.NaN)); // NaN
System.out.println(Math.sqrt(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.sqrt(Double.NEGATIVE_INFINITY)); // NaN

static int subtractExact (int x, int y)

Returns the difference of the arguments, throwing an exception if the result overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.subtractExact(10, 1)); // 9
System.out.println(Math.subtractExact(10, 2)); // 8
System.out.println(Math.subtractExact(10, 3)); // 7

System.out.println(Math.subtractExact(10, -1)); // 11
System.out.println(Math.subtractExact(10, -2)); // 12
System.out.println(Math.subtractExact(10, -3)); // 13

System.out.println(Math.subtractExact(1000, 1)); // 999
System.out.println(Math.subtractExact(-1000, 1)); // -1001

try {
    System.out.println("MIN_VALUE : " + Integer.MIN_VALUE);
    final var value = Math.subtractExact(Integer.MIN_VALUE, 1);

} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//MIN_VALUE : -2147483648
//ArithmeticException!

final int value = Integer.MIN_VALUE - 1;
System.out.println(value); // 2147483647

static long subtractExact (long x, long y)

Returns the difference of the arguments, throwing an exception if the result overflows a long.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to subtractExact(int x, int y).

static double tan (double a)

Returns the trigonometric tangent of an angle.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.tan(-Math.PI * 0.5)); // -1.633123935319537E16 (≒ -Infinity)
System.out.println(Math.tan(-Math.PI * 0.25)); // -0.9999999999999999 (≒ -1.0)
System.out.println(Math.tan(0.0)); // 0.0
System.out.println(Math.tan(Math.PI * 0.25)); // 0.9999999999999999 (≒ 1.0)
System.out.println(Math.tan(Math.PI * 0.5)); // 1.633123935319537E16 (≒ Infinity)

System.out.println(Math.tan(Double.NEGATIVE_INFINITY)); // NaN
System.out.println(Math.tan(Double.POSITIVE_INFINITY)); // NaN
System.out.println(Math.tan(Double.NaN)); // NaN

static double tanh (double x)

Returns the hyperbolic tangent of a double value.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.tanh(-1.0)); // -0.7615941559557649
System.out.println(Math.tanh(-0.5)); // -0.46211715726000974
System.out.println(Math.tanh(0.0)); // 0.0
System.out.println(Math.tanh(0.5)); // 0.46211715726000974
System.out.println(Math.tanh(1.0)); // 0.7615941559557649

System.out.println(Math.tanh(Double.NEGATIVE_INFINITY)); // -1.0
System.out.println(Math.tanh(Double.POSITIVE_INFINITY)); // 1.0
System.out.println(Math.tanh(Double.NaN)); // NaN

static double toDegrees (double angrad)

Converts an angle measured in radians to an approximately equivalent angle measured in degrees.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.toDegrees(0.0)); // 0.0
System.out.println(Math.toDegrees(Math.PI * 0.5)); // 90.0
System.out.println(Math.toDegrees(Math.PI)); // 180.0
System.out.println(Math.toDegrees(Math.PI * 1.5)); // 270.0
System.out.println(Math.toDegrees(Math.PI * 2.0)); // 360.0

static int toIntExact (long value)

Returns the value of the long argument, throwing an exception if the value overflows an int.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.toIntExact(0L)); // 0
System.out.println(Math.toIntExact(100L)); // 100
System.out.println(Math.toIntExact(-100L)); // -100

System.out.println(Math.toIntExact(Integer.MAX_VALUE)); // 2147483647
System.out.println(Math.toIntExact(Integer.MIN_VALUE)); // -2147483648

try {
    final var value = Math.toIntExact(Integer.MAX_VALUE + 1L);

} catch (ArithmeticException e) {
    System.out.println("ArithmeticException!");
}

// Result
// ↓
//ArithmeticException!

static double toRadians (double angdeg)

Converts an angle measured in degrees to an approximately equivalent angle measured in radians.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.toRadians(0.0)); // 0.0
System.out.println(Math.toRadians(90.0)); // 1.5707963267948966 ( ≒ Math.PI * 0.5 )
System.out.println(Math.toRadians(180.0)); // 3.141592653589793 ( ≒ Math.PI * 1.0 )
System.out.println(Math.toRadians(270.0)); // 4.71238898038469 ( ≒ Math.PI * 1.5 )
System.out.println(Math.toRadians(360.0)); // 6.283185307179586 ( ≒ Math.PI * 2.0 )

static double ulp (double d)

Returns the size of an ulp of the argument.

Math (Java SE 18 & JDK 18) 
System.out.println(Math.ulp(1.0)); // 2.220446049250313E-16
System.out.println(Math.ulp(2.0)); // 4.440892098500626E-16
System.out.println(Math.ulp(3.0)); // 4.440892098500626E-16
System.out.println(Math.ulp(4.0)); // 8.881784197001252E-16
System.out.println(Math.ulp(5.0)); // 8.881784197001252E-16

System.out.println(Math.ulp(1000.0)); // 1.1368683772161603E-13
System.out.println(Math.ulp(2000.0)); // 2.2737367544323206E-13
System.out.println(Math.ulp(3000.0)); // 4.547473508864641E-13

System.out.println(Math.ulp(Double.NaN)); // NaN
System.out.println(Math.ulp(Double.POSITIVE_INFINITY)); // Infinity
System.out.println(Math.ulp(Double.NEGATIVE_INFINITY)); // Infinity
System.out.println(Math.ulp(0.0)); // 4.9E-324 ( = Double.MIN_VALUE )
System.out.printf("%a%n", Math.ulp(Double.MAX_VALUE)); // 0x1.0p971

static float ulp (float f)

Returns the size of an ulp of the argument.

Math (Java SE 18 & JDK 18)

This method is equivalent except a type to ulp(double d).

static long unsignedMultiplyHigh (long x, long y)

Returns as a long the most significant 64 bits of the unsigned 128-bit product of two unsigned 64-bit factors.

Math (Java SE 18 & JDK 18)

Please see also : multiplyHigh(long x, long y)

final var x = Long.MAX_VALUE;
System.out.printf("0x%x%n", x); // 0x7fffffffffffffff

System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x10L)); // 0x7
System.out.printf("0x%x%n", Math.unsignedMultiplyHigh(x, 0x10L)); // 0x7

final var x = Long.MIN_VALUE;
System.out.printf("0x%x%n", x); // 0x8000000000000000

System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x10L)); // 0xfffffffffffffff8
System.out.printf("0x%x%n", Math.unsignedMultiplyHigh(x, 0x10L)); // 0x8

System.out.printf("0x%x%n", Math.multiplyHigh(x, 0x100L)); // 0xffffffffffffff80
System.out.printf("0x%x%n", Math.unsignedMultiplyHigh(x, 0x100L)); // 0x80

Related posts

To top of page