A Classe Math Parte 2

Campo E

E – O valor duplo mais próximo do que qualquer outro de e, a base dos logaritmos naturais.

public static final double E – O valor duplo mais próximo do que qualquer outro de e, a base dos logaritmos naturais.

Esse valor E é o número de Euler. A saída no console Java será: 2.718281828459045.

Veja também:

Campo PI

PI – O valor duplo mais próximo do que qualquer outro de pi, a proporção da circunferência de um círculo e seu diâmetro.

public static final double PI – O valor duplo mais próximo do que qualquer outro de pi, a proporção da circunferência de um círculo e seu diâmetro.

Veja também:

Constant Field Values

abs(double a)

abs(double a) – Retorna o valor absoluto de um valor duplo.

public static double abs(double a) – Retorna o valor absoluto de um valor duplo. Se o argumento não for negativo, o argumento será retornado. Se o argumento for negativo, a negação do argumento será retornada. Casos especiais:

Se o argumento for zero positivo ou zero negativo, o resultado será zero positivo.
Se o argumento for infinito, o resultado será infinito positivo.
Se o argumento for NaN, o resultado será NaN.

Nota da API:

Como está implícito acima, uma implementação válida desse método é dada pela expressão abaixo, que calcula um duplo com o mesmo expoente e significante que o argumento, mas com um bit de sinal zero garantido indicando um valor positivo:
Double.longBitsToDouble ((Double.doubleToRawLongBits (a) << 1) >>> 1)

Parâmetros:

a – o argumento cujo valor absoluto deve ser determinado

Retornos:

o valor absoluto do argumento.

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

public class Test { 

   public static void main(String args[]) {
      Integer a = -8;
      double d = -100;
      float f = -90;

      System.out.println(Math.abs(a));
      System.out.println(Math.abs(d));     
      System.out.println(Math.abs(f));    
   }
}

public class Test {

public static void main(String args[]) {

Integer a = -8;

double d = -100;

float f = -90;

System.out.println(Math.abs(a));

System.out.println(Math.abs(d));

System.out.println(Math.abs(f));

}

abs(float a)

abs(float a) – Retorna o valor absoluto de um valor flutuante.

public static float abs(float a) – Retorna o valor absoluto de um valor flutuante. Se o argumento não for negativo, o argumento será retornado. Se o argumento for negativo, a negação do argumento será retornada. Casos especiais:

Se o argumento for zero positivo ou zero negativo, o resultado será zero positivo.
Se o argumento for infinito, o resultado será infinito positivo.
Se o argumento for NaN, o resultado será NaN.

Nota da API:

Como está implícito acima, uma implementação válida desse método é dada pela expressão abaixo, que calcula um float com o mesmo expoente e significando que o argumento, mas com um bit de sinal zero garantido indicando um valor positivo:
Float.intBitsToFloat (0x7fffffff & Float.floatToRawIntBits (a))

Parâmetros:

a – o argumento cujo valor absoluto deve ser determinado

Retornos:

o valor absoluto do argumento.

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

public class Test { 

   public static void main(String args[]) {
      Integer a = -8;
      double d = -100;
      float f = -90;

      System.out.println(Math.abs(a));
      System.out.println(Math.abs(d));     
      System.out.println(Math.abs(f));    
   }
}

public class Test {

public static void main(String args[]) {

Integer a = -8;

double d = -100;

float f = -90;

System.out.println(Math.abs(a));

System.out.println(Math.abs(d));

System.out.println(Math.abs(f));

}

abs(int a)

abs(int a) – Retorna o valor absoluto de um valor int.

public static int abs(int a) – Retorna o valor absoluto de um valor int. Se o argumento não for negativo, o argumento será retornado. Se o argumento for negativo, a negação do argumento será retornada.

Observe que, se o argumento for igual ao valor de Integer.MIN_VALUE, o valor int representável mais negativo, o resultado será o mesmo valor, que é negativo.

Parâmetros:

a – o argumento cujo valor absoluto deve ser determinado

Retornos:

o valor absoluto do argumento.

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

public class Test { 

   public static void main(String args[]) {
      Integer a = -8;
      double d = -100;
      float f = -90;

      System.out.println(Math.abs(a));
      System.out.println(Math.abs(d));     
      System.out.println(Math.abs(f));    
   }
}

public class Test {

public static void main(String args[]) {

Integer a = -8;

double d = -100;

float f = -90;

System.out.println(Math.abs(a));

System.out.println(Math.abs(d));

System.out.println(Math.abs(f));

}

abs(long a)

abs(long a) – Retorna o valor absoluto de um valor longo.

public static long abs(long a) – Retorna o valor absoluto de um valor longo. Se o argumento não for negativo, o argumento será retornado. Se o argumento for negativo, a negação do argumento será retornada.

Observe que, se o argumento for igual ao valor de Long.MIN_VALUE, o valor longo representável mais negativo, o resultado será o mesmo valor, que é negativo.

Parâmetros:

a – o argumento cujo valor absoluto deve ser determinado

Retornos:

o valor absoluto do argumento.

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

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get some longs to find their absolute values
      long x = 76487687634l;
      long y = -1876487618764l;
   
      // get and print their absolute values
      System.out.println("Math.abs(" + x + ")=" + Math.abs(x));
      System.out.println("Math.abs(" + y + ")=" + Math.abs(y));
      System.out.println("Math.abs(-18885785959l)=" + Math.abs(-18885785959l));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get some longs to find their absolute values

long x = 76487687634l;

long y = -1876487618764l;

// get and print their absolute values

System.out.println("Math.abs(" + x + ")=" + Math.abs(x));

System.out.println("Math.abs(" + y + ")=" + Math.abs(y));

System.out.println("Math.abs(-18885785959l)=" + Math.abs(-18885785959l));

}

acos(double a)

acos(double a) – Retorna o arco cosseno de um valor; o ângulo retornado está na faixa de 0,0 a pi.

public static double acos(double a) – Retorna o arco cosseno de um valor; o ângulo retornado está na faixa de 0,0 a pi. Caso especial:

Se o argumento for NaN ou seu valor absoluto for maior que 1, o resultado será NaN.

O resultado calculado deve estar dentro de 1 ulp do resultado exato. Os resultados devem ser semi-monotônicos.

Parâmetros:

a – o valor cujo arco cosseno deve ser retornado.

Retornos:

o arco cosseno do argumento.

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

Live Demo

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get a variable x which is equal to PI/2
      double x = Math.PI / 2;

      // convert x to radians
      x = Math.toRadians(x);

      // get the arc cosine of x
      System.out.println("Math.acos(" + x + ")=" + Math.acos(x));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get a variable x which is equal to PI/2

double x = Math.PI / 2;

// convert x to radians

x = Math.toRadians(x);

// get the arc cosine of x

System.out.println("Math.acos(" + x + ")=" + Math.acos(x));

}

addExact(int x, int y)

addExact(int x, int y) – Retorna a soma de seus argumentos, lançando uma exceção se o resultado exceder um valor int.

public static int addExact(int x, int y) – Retorna a soma de seus argumentos, lançando uma exceção se o resultado exceder um valor int.

Parâmetros:

x – o primeiro valor
y – o segundo valor

Retornos:

o resultado

Lança:

ArithmeticException – se o resultado exceder um valor int

Esse método existe desde a versão 1.8.

Fonte o código: https://javatutorialhq.com/java/lang/strictmath-class-tutorial/addexact-int-method-example/

package com.javatutorialhq.java.examples;


import java.util.Scanner;

/*
 * A java example source code to demonstrate
 * the use of addExact(int x, int y) 
 * method of Math class
 */

public class StrictMathAddExactIntExample {

	public static void main(String[] args) {
		
		// Ask user input
		System.out.print("Enter a value:");
		
		// declare the scanner object
		Scanner scan = new Scanner(System.in);		
		
		// use scanner to get the user input and store it to a variable
		int intValue1 = scan.nextInt();		
		
		
		// Ask another user input
		System.out.print("Enter another value:");
		
		// store it to a variable
		int intValue2 = scan.nextInt();	
		
		// close the scanner object
		scan.close();		
		
		// get the result	
		int result = StrictMath.addExact(intValue1, intValue2);
		
		// print the result
		System.out.println("result: "+result);

	}

}

package com.javatutorialhq.java.examples;

import java.util.Scanner;

* A java example source code to demonstrate

* the use of addExact(int x, int y)

* method of Math class

public class StrictMathAddExactIntExample {

public static void main(String[] args) {

// Ask user input

System.out.print("Enter a value:");

// declare the scanner object

Scanner scan = new Scanner(System.in);

// use scanner to get the user input and store it to a variable

int intValue1 = scan.nextInt();

// Ask another user input

System.out.print("Enter another value:");

// store it to a variable

int intValue2 = scan.nextInt();

// close the scanner object

scan.close();

// get the result

int result = StrictMath.addExact(intValue1, intValue2);

// print the result

System.out.println("result: "+result);

}

addExact(long x, long y)

addExact(long x, long y) – Retorna a soma de seus argumentos, lançando uma exceção se o resultado exceder um tempo.

public static long addExact(long x, long y) – Retorna a soma de seus argumentos, lançando uma exceção se o resultado exceder um tempo.

Parâmetros:

x – o primeiro valor
y – o segundo valor

Retornos:

o resultado

Lança:

ArithmeticException – se o resultado exceder um longo

Esse método existe desde a versão 1.8.

Fonte do código: https://www.geeksforgeeks.org/java-math-addexactlong-x-long-y-method/

import java.lang.Math; 
  
class Gfg1 { 
  
    // driver code 
    public static void main(String args[]) 
    { 
        long x = 9999999999l; 
        long y = 1l; 
  
        System.out.println(Math.addExact(x, y)); 
    } 
}

import java.lang.Math;

class Gfg1 {

// driver code

public static void main(String args[])

{

long x = 9999999999l;

long y = 1l;

System.out.println(Math.addExact(x, y));

}

Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Math.html

Campo E

Campo PI

abs(double a)

abs(float a)

abs(int a)

abs(long a)

acos(double a)

addExact(int x, int y)

addExact(long x, long y)

Variáveis com Números Decimais

O Jogo Roda da Fortuna em Texto

Classe Character #11

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

Campo E

Campo PI

abs​(double a)

abs​(float a)

abs​(int a)

abs​(long a)

acos​(double a)

addExact​(int x, int y)

addExact​(long x, long y)

Variáveis com Números Decimais

O Jogo Roda da Fortuna em Texto

Classe Character #11

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

abs(double a)

abs(float a)

abs(int a)

abs(long a)

acos(double a)

addExact(int x, int y)

addExact(long x, long y)