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/
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/
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/
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/
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
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
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
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
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/
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