decrementExact(int a)
decrementExact(int a) – Retorna o argumento decrementado por um, lançando uma exceção se o resultado exceder um valor int.
public static int decrementExact(int a) – Retorna o argumento decrementado por um, lançando uma exceção se o resultado exceder um valor int. O estouro ocorre apenas para o valor mínimo.
Parâmetros:
a – o valor a diminuir
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/decrementexact-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 * decrementExact() method of Math class */ public class MathDecrementExactExample { 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 decrementExact int result = Math.decrementExact(value); System.out.println("Result of the operation is " + result); } } |
decrementExact(long a)
decrementExact(long a) – Retorna o argumento decrementado por um, lançando uma exceção se o resultado exceder um tempo.
public static long decrementExact(long a) – Retorna o argumento decrementado por um, lançando uma exceção se o resultado exceder um tempo. O estouro ocorre apenas para o valor mínimo.
Parâmetros:
a – o valor a diminuir
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um longo
Esse método existe desde a versão 1.8.
Fonte do código: https://www.javatpoint.com/java-math-decrementexact-method
|
1 2 3 4 5 6 7 8 9 |
public class DecrementExactExample4 { public static void main(String[] args) { long a = Long.MIN_VALUE; // Input long overflow, Output ArithmeticException System.out.println(Math.decrementExact(a)); } } |
exp(double a)
exp(double a) – Retorna o número de Euler e elevado ao poder de um valor duplo.
public static double exp(double a) – Retorna o número de Euler e elevado ao poder de um valor duplo. Casos especiais:
- Se o argumento for NaN, o resultado será NaN.
- Se o argumento for infinito positivo, o resultado será infinito positivo.
- Se o argumento for infinito negativo, o resultado será zero positivo.
O resultado calculado deve estar dentro de 1 ulp do resultado exato. Os resultados devem ser semi-monotônicos.
Parâmetros:
a – o expoente para aumentar e para.
Retornos:
o valor ea, onde e é a base dos logaritmos naturais.
Fonte do código: https://www.tutorialspoint.com/java/lang/math_exp.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package com.tutorialspoint; import java.lang.*; public class MathDemo { public static void main(String[] args) { // get two double numbers double x = 5; double y = 0.5; // print e raised at x and y System.out.println("Math.exp(" + x + ")=" + Math.exp(x)); System.out.println("Math.exp(" + y + ")=" + Math.exp(y)); } } |
expm1(double x)
expm1(double x) – Retorna ex -1.
public static double expm1(double x) – Retorna ex -1. Observe que, para valores de x próximos a 0, a soma exata de expm1 (x) + 1 está muito mais próxima do resultado real de ex do que exp (x).
Casos especiais:
- Se o argumento for NaN, o resultado será NaN.
- Se o argumento for infinito positivo, o resultado será infinito positivo.
- Se o argumento for infinito negativo, o resultado será -1,0.
- Se o argumento for zero, o resultado será zero com o mesmo sinal que o argumento.
O resultado calculado deve estar dentro de 1 ulp do resultado exato. Os resultados devem ser semi-monotônicos. O resultado de expm1 para qualquer entrada finita deve ser maior ou igual a -1,0. Observe que, uma vez que o resultado exato de ex-1 esteja a 1/2 ul do valor-limite -1, -1,0 deve ser retornado.
Parâmetros:
x – o expoente para elevar e para no cálculo de ex -1.
Retornos:
o valor ex – 1.
Essa versão existe desde a versão 1.5.
Fonte do código: https://www.tutorialspoint.com/java/lang/math_expm1.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package com.tutorialspoint; import java.lang.*; public class MathDemo { public static void main(String[] args) { // get two double numbers double x = 5; double y = 0.5; // call expm1 for both numbers and print the result System.out.println("Math.expm1(" + x + ")=" + Math.expm1(x)); System.out.println("Math.expm1(" + y + ")=" + Math.expm1(y)); } } |
floor(double a)
floor(double a) – Retorna o maior valor duplo (mais próximo do infinito positivo) que é menor ou igual ao argumento e é igual a um número inteiro matemático.
public static double floor(double a) – Retorna o maior valor duplo (mais próximo do infinito positivo) que é menor ou igual ao argumento e é igual a um número inteiro matemático. Casos especiais:
- Se o valor do argumento já for igual a um número inteiro matemático, o resultado será o mesmo que o argumento.
- Se o argumento for NaN ou um infinito ou zero positivo ou zero negativo, o resultado será o mesmo que o argumento.
Parâmetros:
a – um valor.
Retornos:
o maior (ponto mais próximo do infinito positivo) valor de ponto flutuante menor ou igual ao argumento e igual a um número inteiro matemático.
Fonte do código: https://www.tutorialspoint.com/java/lang/math_floor.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; // call floor and print the result System.out.println("Math.floor(" + x + ")=" + Math.floor(x)); System.out.println("Math.floor(" + y + ")=" + Math.floor(y)); System.out.println("Math.floor(0)=" + Math.floor(0)); } } |
floorDiv(int x, int y)
floorDiv(int x, int y) – Retorna o maior valor int (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico.
public static int floorDiv(int x, int y) – Retorna o maior valor int (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico. Há um caso especial, se o dividendo for o Inteiro.MIN_VALUE e o divisor for -1, ocorrerá um estouro de número inteiro e o resultado será igual a Inteiro.MIN_VALUE.
A divisão inteira normal opera no modo de arredondamento a zero (truncamento). Em vez disso, esta operação atua sob o round em direção ao modo de arredondamento infinito negativo (piso). O modo de arredondamento do piso fornece resultados diferentes do truncamento quando o resultado exato é negativo.
- Se os sinais dos argumentos forem os mesmos, os resultados do floorDiv e do operador / serão os mesmos.
- Por exemplo, floorDiv (4, 3) == 1 e (4/3) == 1.
- Se os sinais dos argumentos forem diferentes, o quociente é negativo e floorDiv retorna o número inteiro menor ou igual ao quociente e o operador / retorna o número inteiro mais próximo de zero.
- Por exemplo, floorDiv (-4, 3) == -2, enquanto (-4 / 3) == -1.
Parâmetros:
x – o dividendo
y – o divisor
Retornos:
o maior valor int (mais próximo do infinito positivo) int que é menor ou igual ao quociente algébrico.
Lançamentos:
ArithmeticException – se o divisor y for zero
Esse método existe desde a versão 1.8.
Veja também:
floorMod(int, int), floor(double)
Fonte do código: https://www.javatpoint.com/java-math-floordiv-method
|
1 2 3 4 5 6 7 8 9 10 |
public class FloorDivExample1 { public static void main(String[] args) { int x = 25; int y= 3; // 25/3 value is 8.33 so floor(8.33) = 8 System.out.println(Math.floorDiv(x, y)); } } |
floorDiv(long x, int y)
floorDiv(long x, int y) – Retorna o maior valor longo (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico.
public static long floorDiv(long x, int y) – Retorna o maior valor longo (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico. Há um caso especial, se o dividendo for Long.MIN_VALUE e o divisor for -1, ocorrerá um estouro de número inteiro e o resultado será igual a Long.MIN_VALUE.
A divisão inteira normal opera no modo de arredondamento a zero (truncamento). Em vez disso, esta operação atua sob o round em direção ao modo de arredondamento infinito negativo (piso). O modo de arredondamento do piso fornece resultados diferentes do truncamento quando o resultado exato é negativo.
Para exemplos, consulte floorDiv (int, int).
Parâmetros:
x – o dividendo
y – o divisor
Retornos:
o maior valor int (mais próximo do infinito positivo) int que é menor ou igual ao quociente algébrico.
Lançamentos:
ArithmeticException – se o divisor y for zero
Esse método existe desde a versão 9.
Veja também:
floorMod(long, int), floor(double)
Fonte do código: https://www.javatpoint.com/java-math-floordiv-method
|
1 2 3 4 5 6 7 8 9 10 |
public class FloorDivExample3 { public static void main(String[] args) { long x = 6754883; int y = 0; // Second argument is zero, Output is Airthmetic Exception System.out.println(Math.floorDiv(x, y)); } } |
floorDiv(long x, long y)
floorDiv(long x, long y) – Retorna o maior valor longo (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico.
public static long floorDiv(long x, long y) – Retorna o maior valor longo (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico. Há um caso especial, se o dividendo for Long.MIN_VALUE e o divisor for -1, ocorrerá um estouro de número inteiro e o resultado será igual a Long.MIN_VALUE.
A divisão inteira normal opera no modo de arredondamento a zero (truncamento). Em vez disso, esta operação atua sob o round em direção ao modo de arredondamento infinito negativo (piso). O modo de arredondamento do piso fornece resultados diferentes do truncamento quando o resultado exato é negativo.
Para exemplos, consulte floorDiv (int, int).
Parâmetros:
x – o dividendo
y – o divisor
Retornos:
o maior valor longo (mais próximo do infinito positivo) que é menor ou igual ao quociente algébrico.
Lançamentos:
ArithmeticException – se o divisor y for zero
Esse método existe desde a versão 1.8.
Veja também:
floorMod(long, long), floor(double)
Fonte do código: https://www.tutorialandexample.com/java-math-floordiv-method/
|
1 2 3 4 5 6 7 8 |
public class JavaMathFloorDivExample3 { public static void main(String[] args) { long x = -2125; long y= 1; //it returns an Airthmetic Exception, if the Second argument is zero System.out.println(Math.floorDiv(x, y)); } } |
floorMod(int x, int y)
floorMod(int x, int y) – Retorna o módulo de piso dos argumentos int.
public static int floorMod(int x, int y) – Retorna o módulo de piso dos argumentos 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
A diferença nos valores entre floorMod e o operador% se deve à diferença entre floorDiv que retorna o número inteiro menor ou igual ao quociente e o operador / que retorna o número inteiro mais próximo de zero.
Exemplos:
- Se os sinais dos argumentos forem os mesmos, os resultados do floorMod e do operador% serão os mesmos.
- floorMod (+4, +3) == +1; e (+4% +3) == +1
- floorMod (-4, -3) == -1; e (-4% -3) == -1
- Se os sinais dos argumentos forem diferentes, os resultados diferem do operador%.
- floorMod (+4, -3) == -2; e (+4% -3) == +1
- floorMod (-4, +3) == +2; e (-4% +3) == -1
Se os sinais dos argumentos são desconhecidos e é necessário um módulo positivo, ele pode ser calculado como (floorMod (x, y) + abs (y))% abs (y).
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.geeksforgeeks.org/math-floormod-method-in-java/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import java.lang.Math; class Gfg1 { public static void main(String args[]) { int a = 25, b = 5; System.out.println(Math.floorMod(a, b)); // Divisor and dividend is having same sign int c = 123, d = 50; System.out.println(Math.floorMod(c, d)); // Divisor is having negative sign int e = 123, f = -50; System.out.println(Math.floorMod(e, f)); // Dividend is having negative sign int g = -123, h = 50; System.out.println(Math.floorMod(g, h)); } } |
Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Math.html
Deixe um comentário