floorMod(long x, int y)
floorMod(long x, int y) – Retorna o módulo de piso dos argumentos long e int.
public static int floorMod(long x, int y) – Retorna o módulo de piso dos argumentos long e int.
O módulo do piso é x – (floorDiv (x, y) * y), tem o mesmo sinal que o divisor y e está no intervalo de -abs (y) <r <+ abs (y).
A relação entre floorDiv e floorMod é tal que:
- floorDiv(x, y) * y + floorMod(x, y) == x
Para exemplos, consulte floorMod (int, int).
Parâmetros:
x – o dividendo
y – o divisor
Retornos:
o módulo de piso x – (floorDiv (x, y) * y)
Lançamentos:
ArithmeticException – se o divisor y for zero
Esse método existe desde a versão 9.
Veja também:
Fonte do código: https://www.tutorialandexample.com/java-math-floormod-method/
|
1 2 3 4 5 6 7 8 |
public class JavaMathFloorModExample2 { public static void main(String[] args) { int x = 2125; long y= -10; // divides x an y and returns the remainder System.out.println("Remainder : "+Math.floorMod(x, y)); } } |
floorMod(long x, long y)
floorMod(long x, long y) – Retorna o módulo de piso dos argumentos longos.
public static long floorMod(long x, long y) – Retorna o módulo de piso dos argumentos longos.
O módulo do piso é x – (floorDiv (x, y) * y), tem o mesmo sinal que o divisor y e está no intervalo de -abs (y) <r <+ abs (y).
A relação entre floorDiv e floorMod é tal que:
- floorDiv(x, y) * y + floorMod(x, y) == x
Para exemplos, consulte floorMod (int, int).
Parâmetros:
x – o dividendo
y – o divisor
Retornos:
o módulo de piso x – (floorDiv (x, y) * y)
Lançamentos:
ArithmeticException – se o divisor y for zero
Esse método existe desde a versão 1.8.
Veja também:
Fonte do código: https://www.tutorialandexample.com/java-math-floormod-method/
|
1 2 3 4 5 6 7 8 |
public class JavaMathFloorModExample3 { public static void main(String[] args) { long x = -2125; long y= 0; //it returns an Airthmetic Exception, if the Second argument is zero System.out.println(Math.floorMod(x, y)); } } |
fma(double a, double b, double c)
fma(double a, double b, double c) – Retorna a adição multiplicada com fusão dos três argumentos; isto é, retorna o produto exato dos dois primeiros argumentos somados com o terceiro argumento e depois arredondado uma vez para o dobro mais próximo.
public static double fma(double a, double b, double c) – Retorna a adição multiplicada com fusão dos três argumentos; isto é, retorna o produto exato dos dois primeiros argumentos somados com o terceiro argumento e depois arredondado uma vez para o dobro mais próximo. O arredondamento é feito usando o arredondamento para o modo de arredondamento uniforme mais próximo. Por outro lado, se a * b + c é avaliado como uma expressão regular de ponto flutuante, dois erros de arredondamento são envolvidos, o primeiro para a operação de multiplicação e o segundo para a operação de adição.
Casos especiais:
- Se qualquer argumento for NaN, o resultado será NaN.
- Se um dos dois primeiros argumentos for infinito e o outro for zero, o resultado será NaN.
- Se o produto exato dos dois primeiros argumentos for infinito (em outras palavras, pelo menos um dos argumentos for infinito e o outro não for zero nem NaN) e o terceiro argumento for uma infinidade do sinal oposto, o resultado será NaN.
Observe que fma (a, 1.0, c) retorna o mesmo resultado que (a + c). No entanto, fma (a, b, +0.0) nem sempre retorna o mesmo resultado que (a * b), pois fma (-0.0, +0.0, +0.0) é +0.0 enquanto (-0.0 * +0.0) é -0.0 ; fma (a, b, -0,0) é equivalente a (a * b) no entanto.
Nota da API:
Este método corresponde à operação fusedMultiplyAdd definida em IEEE 754-2008.
Parâmetros:
a – um valor
b – um valor
c – um valor
Retornos:
(a × b + c) calculado, como se tivesse alcance e precisão ilimitados, e arredondado uma vez para o valor duplo mais próximo
Esse método existe desde a versão 9.
Fonte do código: https://www.geeksforgeeks.org/strictmath-fma-method-in-java-with-examples/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class GFG { // Main method public static void main(String[] args) { // three double values double a = 9.20, b = 6.30, c = 4.10; // apply fma method double d = StrictMath.fma(a, b, c); // print result System.out.println(a + " * " + b + " + " + c + " = " + d); } } |
fma(float a, float b, float c)
fma(float a, float b, float c) – Retorna a adição multiplicada com fusão dos três argumentos; isto é, retorna o produto exato dos dois primeiros argumentos somados com o terceiro argumento e, em seguida, arredondado uma vez para o flutuador mais próximo.
public static float fma(float a, float b, float c) – Retorna a adição multiplicada com fusão dos três argumentos; isto é, retorna o produto exato dos dois primeiros argumentos somados com o terceiro argumento e, em seguida, arredondado uma vez para o flutuador mais próximo. O arredondamento é feito usando o arredondamento para o modo de arredondamento uniforme mais próximo. Por outro lado, se a * b + c é avaliado como uma expressão regular de ponto flutuante, dois erros de arredondamento são envolvidos, o primeiro para a operação de multiplicação e o segundo para a operação de adição.
Casos especiais:
- Se qualquer argumento for NaN, o resultado será NaN.
- Se um dos dois primeiros argumentos for infinito e o outro for zero, o resultado será NaN.
- Se o produto exato dos dois primeiros argumentos for infinito (em outras palavras, pelo menos um dos argumentos for infinito e o outro não for zero nem NaN) e o terceiro argumento for uma infinidade do sinal oposto, o resultado será NaN.
Observe que fma (a, 1.0f, c) retorna o mesmo resultado que (a + c). No entanto, fma (a, b, + 0,0f) nem sempre retorna o mesmo resultado que (a * b), pois fma (-0,0f, + 0,0f, + 0,0f) é + 0,0f enquanto (-0,0f * + 0,0f) é -0,0f; fma (a, b, -0,0f) é equivalente a (a * b) no entanto.
Nota da API:
Este método corresponde à operação fusedMultiplyAdd definida em IEEE 754-2008.
Parâmetros:
a – um valor
b – um valor
c – um valor
Retornos:
(a × b + c) calculado, como se tivesse alcance e precisão ilimitados, e arredondado uma vez para o valor flutuante mais próximo
Esse método existe desde a versão 9.
Fonte do código: https://www.geeksforgeeks.org/math-fma-method-in-java-with-examples/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class GFG { // Main method public static void main(String[] args) { // three double values float a = 29.20f, b = 18.40f, c = 43.10f; // apply fma method float d = Math.fma(a, b, c); // print result System.out.println(a + " * " + b + " + " + c + " = " + d); } } |
getExponent(double d)
getExponent(double d) – Retorna o expoente imparcial usado na representação de um duplo.
public static int getExponent(double d) – Retorna o expoente imparcial usado na representação de um duplo. Casos especiais:
- Se o argumento for NaN ou infinito, o resultado será Double.MAX_EXPONENT + 1.
- Se o argumento for zero ou subnormal, o resultado será Double.MIN_EXPONENT -1.
Parâmetros:
d – um valor duplo
Retornos:
o expoente imparcial do argumento
Esse método existe desde a versão 1.6.
Fonte do código: https://www.tutorialspoint.com/java/lang/math_getexponent_double.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.tutorialspoint; import java.lang.*; public class MathDemo { public static void main(String[] args) { // get two double numbers double x = 60984.1; double y = -497.99; // print the unbiased exponent of them System.out.println("Math.getExponent(" + x + ")=" + Math.getExponent(x)); System.out.println("Math.getExponent(" + y + ")=" + Math.getExponent(y)); System.out.println("Math.getExponent(0)=" + Math.getExponent(0)); } } |
getExponent(float f)
getExponent(float f) – Retorna o expoente imparcial usado na representação de um flutuador.
public static int getExponent(float f) – Retorna o expoente imparcial usado na representação de um flutuador. Casos especiais:
- Se o argumento for NaN ou infinito, o resultado será Float.MAX_EXPONENT + 1.
- Se o argumento for zero ou subnormal, o resultado será Float.MIN_EXPONENT -1.
Parâmetros:
f – um valor flutuante
Retornos:
o expoente imparcial do argumento
Esse método existe desde a versão 1.6.
Fonte do código: https://www.technicalkeeda.com/java-tutorials/java-math-getexponent-float-f-method-example
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package com.technicalkeeda; public class App { public static void main(String[] args) { float firstValue = 12.52f; float secondValue = 54.54f; int firstValueResult = Math.getExponent(firstValue); int secondValueResult = Math.getExponent(secondValue); System.out.println("The unbiased exponent of firstValue :- " + firstValueResult); System.out.println("The unbiased exponent of secondValue :- " + secondValueResult); } } |
hypot(double x, double y)
hypot(double x, double y) – Retorna sqrt (x2 +y2) sem estouros ou estouros intermediários.
public static double hypot(double x, double y) – Casos especiais:
- Se um dos argumentos for infinito, o resultado será infinito positivo.
- Se um dos argumentos for NaN e nenhum for infinito, o resultado será NaN.
O resultado calculado deve estar dentro de 1 ulp do resultado exato. Se um parâmetro for mantido constante, os resultados deverão ser semi-monotônicos no outro parâmetro.
Parâmetros:
x – um valor
y – um valor
Retornos:
sqrt (x2 +y2) sem overflow ou underflow intermediário
Esse método existe desde a versão 1.5.
Fonte do código: http://www.java2s.com/Code/JavaAPI/java.lang/MathhypotdoublexdoubleyReturnssqrtx2y2withoutintermediateoverfloworunderflow.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public class Main { public static void main(String[] args) { int a = 10; int b = -50; int c = 3; double x = 25.0; double y = 3.0; double z = 4.0; System.out.println("abs(b) = " + Math.abs(b)); System.out.println("cbrt(x) = " + Math.cbrt(x)); System.out.println("exp(y) = " + Math.exp(z)); System.out.println("hypot(y, z)= " + Math.hypot(y, z)); System.out.println("log(y) = " + Math.log(y)); System.out.println("log10(y) = " + Math.log10(y)); System.out.println("max(a, b) = " + Math.max(a, b)); System.out.println("min(a, b) = " + Math.min(a, b)); System.out.println("pow(a, c) = " + Math.pow(a, c)); System.out.println("random() = " + Math.random()); System.out.println("signum(b) = " + Math.signum(b)); System.out.println("sqrt(x) = " + Math.sqrt(y)); } } |
IEEEremainder(double f1, double f2)
IEEEremainder(double f1, double f2) – Calcula a operação restante em dois argumentos, conforme prescrito pelo padrão IEEE 754.
public static double IEEEremainder(double f1, double f2) – Calcula a operação restante em dois argumentos, conforme prescrito pelo padrão IEEE 754. O valor restante é matematicamente igual a f1 – f2 × n, onde n é o número inteiro matemático mais próximo do valor matemático exato do quociente f1 / f2, e se dois inteiros matemáticos estão igualmente próximos de f1 / f2, então n é o número inteiro isso é par. Se o restante for zero, seu sinal é o mesmo que o primeiro argumento. Casos especiais:
- Se um dos argumentos for NaN, ou o primeiro argumento for infinito, ou o segundo argumento for zero positivo ou zero negativo, o resultado será NaN.
- Se o primeiro argumento for finito e o segundo argumento for infinito, o resultado será o mesmo que o primeiro argumento.
Parâmetros:
f1 – o dividendo.
f2 – o divisor.
Retornos:
o restante quando f1 é dividido por f2.
Fonte do código: https://www.tutorialspoint.com/java/lang/math_ieeeremainder.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package com.tutorialspoint; import java.lang.*; public class MathDemo { public static void main(String[] args) { // get two double numbers double x = 60984.1; double y = -497.99; // get the remainder when x/y System.out.println("Math.IEEEremainder(" + x + "," + y + ")=" + Math.IEEEremainder(x, y)); // get the remainder when y/x System.out.println("Math.IEEEremainder(" + y + "," + x + ")=" + Math.IEEEremainder(y, x)); } } |
incrementExact(int a)
incrementExact(int a) – Retorna o argumento incrementado por um, lançando uma exceção se o resultado exceder um valor int.
public static int incrementExact(int a) – Retorna o argumento incrementado por um, lançando uma exceção se o resultado exceder um valor int. O estouro ocorre apenas para o valor máximo.
Parâmetros:
a – o valor a ser incrementado
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um valor int
Esse método existe desde a versão 1.8.
Fonte do código: https://javatutorialhq.com/java/lang/math-class-tutorial-2/incrementexact-method-example/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
package com.javatutorialhq.java.examples; import java.util.Scanner; /* * This example source code demonstrates the use of * incrementExact() method of Math class */ public class MathIncrementExactExample { public static void main(String[] args) { // Ask for user input System.out.print("Enter an input:"); // use scanner to read the console input Scanner scan = new Scanner(System.in); // Assign the user to String variable String s = scan.nextLine(); // close the scanner object scan.close(); // convert the string input to double int value = Integer.parseInt(s); // get the result of incrementExact int result = Math.incrementExact(value); System.out.println("Result of the operation is " + result); } } |
Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Math.html
Deixe um comentário