A Classe Math Parte 4

Table of Contents

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/

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);

	}

}

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

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));  
    }  
}

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 e^a, onde e é a base dos logaritmos naturais.

Fonte do código: https://www.tutorialspoint.com/java/lang/math_exp.htm

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));
   }
}

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 e^x -1.

public static double expm1(double x) – Retorna e^x -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 e^x-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 e^x -1.

Retornos:

o valor e^x – 1.

Essa versão existe desde a versão 1.5.

Fonte do código: https://www.tutorialspoint.com/java/lang/math_expm1.htm

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));
   }
}

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

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));
   }
}

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

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));  
    }  
}

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.

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

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));  
    }  
}

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.

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/

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));
    }
}

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:

floorDiv(int, int)

Fonte do código: https://www.geeksforgeeks.org/math-floormod-method-in-java/

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)); 
    } 
}

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

decrementExact(int a)

decrementExact(long a)

exp(double a)

expm1(double x)

floor(double a)

floorDiv(int x, int y)

floorDiv(long x, int y)

floorDiv(long x, long y)

floorMod(int x, int y)

DropShadow

Ebook – Aprendendo Java para Certificação Volume 2

HBox, VBox e ButtonBar

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

decrementExact​(int a)

decrementExact​(long a)

exp​(double a)

expm1​(double x)

floor​(double a)

floorDiv​(int x, int y)

floorDiv​(long x, int y)

floorDiv​(long x, long y)

floorMod​(int x, int y)

DropShadow

Ebook – Aprendendo Java para Certificação Volume 2

HBox, VBox e ButtonBar

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

decrementExact(int a)

decrementExact(long a)

exp(double a)

expm1(double x)

floor(double a)

floorDiv(int x, int y)

floorDiv(long x, int y)

floorDiv(long x, long y)

floorMod(int x, int y)