A Classe Math Parte 8

negateExact(long a)

negateExact(long a) – Retorna a negação do argumento, lançando uma exceção se o resultado exceder um tempo.

public static long negateExact(long a) – Retorna a negação do argumento, 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 negar

Retornos:

o resultado

Lançamentos:

ArithmeticException – se o resultado exceder um longo

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

Fonte do site: https://www.javatpoint.com/java-math-negateexact-method

public class NegateExactExample2
{
public static void main(String[] args)
{
long a = -830;
// Input -a, Output a
System.out.println(Math.negateExact(a));
}
}

nextAfter(double start, double direction)

nextAfter(double start, double direction) – Retorna o número de ponto flutuante adjacente ao primeiro argumento na direção do segundo argumento.

public static double nextAfter(double start, double direction) – Retorna o número de ponto flutuante adjacente ao primeiro argumento na direção do segundo argumento. Se ambos os argumentos forem comparados como iguais, o segundo argumento será retornado.

Casos especiais:

Se um dos argumentos for um NaN, o NaN será retornado.
Se ambos os argumentos tiverem zeros assinados, a direção será retornada inalterada (conforme implícito no requisito de retornar o segundo argumento se os argumentos forem comparados como iguais).
Se o início for ± Double.MIN_VALUE e a direção tiver um valor tal que o resultado deva ter uma magnitude menor, será retornado um zero com o mesmo sinal do início.
Se o início for infinito e a direção tiver um valor tal que o resultado deva ter uma magnitude menor, será retornado Double.MAX_VALUE com o mesmo sinal que o início.
Se start for igual a ± Double.MAX_VALUE e direction tiver um valor tal que o resultado deva ter uma magnitude maior, será retornado um infinito com o mesmo sinal de start.

Parâmetros:

start – iniciando o valor do ponto flutuante
direction – valor que indica quais vizinhos ou start de start devem ser retornados

Retornos:

O número de ponto flutuante adjacente ao início na direção da direção.

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

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

Live Demo

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get two double numbers
      double x = 98759.765;
      double y = 154.28764;
   
      // print the next number for x towards y
      System.out.println("Math.nextAfter(" + x + "," + y + ")="
         + Math.nextAfter(x, y));

      // print the next number for y towards x
      System.out.println("Math.nextAfter(" + y + "," + x + ")="
         + Math.nextAfter(y, x));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get two double numbers

double x = 98759.765;

double y = 154.28764;

// print the next number for x towards y

System.out.println("Math.nextAfter(" + x + "," + y + ")="

+ Math.nextAfter(x, y));

// print the next number for y towards x

System.out.println("Math.nextAfter(" + y + "," + x + ")="

+ Math.nextAfter(y, x));

}

nextAfter(float start, double direction)

nextAfter(float start, double direction) – Retorna o número de ponto flutuante adjacente ao primeiro argumento na direção do segundo argumento.

public static float nextAfter(float start, double direction) – Retorna o número de ponto flutuante adjacente ao primeiro argumento na direção do segundo argumento. Se os dois argumentos forem comparados como iguais, um valor equivalente ao segundo argumento será retornado.

Casos especiais:

Se um dos argumentos for um NaN, o NaN será retornado.
Se ambos os argumentos forem zeros assinados, um valor equivalente à direção será retornado.
Se o início for ± Float.MIN_VALUE e a direção tiver um valor tal que o resultado deva ter uma magnitude menor, será retornado um zero com o mesmo sinal do início.
Se o início for infinito e a direção tiver um valor tal que o resultado deva ter uma magnitude menor, retornará Float.MAX_VALUE com o mesmo sinal que o início.
Se start for igual a ± Float.MAX_VALUE e direction tiver um valor tal que o resultado deva ter uma magnitude maior, será retornado um infinito com o mesmo sinal que start.

Parâmetros:

start – iniciando o valor do ponto flutuante
direction – valor que indica quais vizinhos ou start de start devem ser retornados

Retornos:

O número de ponto flutuante adjacente ao início na direção da direção.

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

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

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get two numbers
      float x = 98759.765f;
      double y = 154.28764;
   
      // print the next number for x towards y
      System.out.println("Math.nextAfter(" + x + "," + y + ")="
         + Math.nextAfter(x, y));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get two numbers

float x = 98759.765f;

double y = 154.28764;

// print the next number for x towards y

System.out.println("Math.nextAfter(" + x + "," + y + ")="

+ Math.nextAfter(x, y));

}

nextDown(double d)

nextDown(double d) – Retorna o valor do ponto flutuante adjacente a d na direção do infinito negativo.

public static double nextDown(double d) – Retorna o valor do ponto flutuante adjacente a d na direção do infinito negativo. Este método é semanticamente equivalente a nextAfter (d, Double.NEGATIVE_INFINITY); no entanto, uma implementação nextDown pode ser executada mais rapidamente que sua chamada nextAfter equivalente.

Casos especiais:

Se o argumento for NaN, o resultado será NaN.
Se o argumento for infinito negativo, o resultado será infinito negativo.
Se o argumento for zero, o resultado será -Double.MIN_VALUE

Parâmetros:

d – iniciando o valor do ponto flutuante

Retornos:

O valor do ponto flutuante adjacente mais próximo do infinito negativo.

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

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

import java.lang.Math; 
  
class Gfg { 
  
    // driver code 
    public static void main(String args[]) 
    { 
        double g = 23.44; 
  
        // Input double value, Output adjacent floating-point 
        System.out.println(Math.nextDown(g)); 
  
        float gf = 28.1f; 
  
        // Input float value, Output adjacent floating-point 
        System.out.println(Math.nextDown(gf)); 
  
        double a = 0.0 / 0; 
  
        // Input NaN, Output NaN 
        System.out.println(Math.nextDown(a)); 
  
        float b = 0.0f; 
  
        // Input zero, Output - Float.MIN_VALUE for float 
        System.out.println(Math.nextDown(b)); 
  
        double c = -1.0 / 0; 
  
        // Input negative infinity, Output negative infinity 
        System.out.println(Math.nextDown(c)); 
    } 
}

import java.lang.Math;

class Gfg {

// driver code

public static void main(String args[])

{

double g = 23.44;

// Input double value, Output adjacent floating-point

System.out.println(Math.nextDown(g));

float gf = 28.1f;

// Input float value, Output adjacent floating-point

System.out.println(Math.nextDown(gf));

double a = 0.0 / 0;

// Input NaN, Output NaN

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

float b = 0.0f;

// Input zero, Output - Float.MIN_VALUE for float

System.out.println(Math.nextDown(b));

double c = -1.0 / 0;

// Input negative infinity, Output negative infinity

System.out.println(Math.nextDown(c));

}

nextDown(float f)

nextDown(float f) – Retorna o valor do ponto flutuante adjacente a f na direção do infinito negativo.

public static float nextDown(float f) – Retorna o valor do ponto flutuante adjacente a f na direção do infinito negativo. Este método é semanticamente equivalente a nextAfter (f, Float.NEGATIVE_INFINITY); no entanto, uma implementação nextDown pode ser executada mais rapidamente que sua chamada nextAfter equivalente.

Casos especiais:

Se o argumento for NaN, o resultado será NaN.
Se o argumento for infinito negativo, o resultado será infinito negativo.
Se o argumento for zero, o resultado será -Float.MIN_VALUE

Parâmetros:

f – iniciando o valor do ponto flutuante

Retornos:

O valor do ponto flutuante adjacente mais próximo do infinito negativo.

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

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

import java.lang.Math; 
  
class Gfg { 
  
    // driver code 
    public static void main(String args[]) 
    { 
        double g = 23.44; 
  
        // Input double value, Output adjacent floating-point 
        System.out.println(Math.nextDown(g)); 
  
        float gf = 28.1f; 
  
        // Input float value, Output adjacent floating-point 
        System.out.println(Math.nextDown(gf)); 
  
        double a = 0.0 / 0; 
  
        // Input NaN, Output NaN 
        System.out.println(Math.nextDown(a)); 
  
        float b = 0.0f; 
  
        // Input zero, Output - Float.MIN_VALUE for float 
        System.out.println(Math.nextDown(b)); 
  
        double c = -1.0 / 0; 
  
        // Input negative infinity, Output negative infinity 
        System.out.println(Math.nextDown(c)); 
    } 
}

import java.lang.Math;

class Gfg {

// driver code

public static void main(String args[])

{

double g = 23.44;

// Input double value, Output adjacent floating-point

System.out.println(Math.nextDown(g));

float gf = 28.1f;

// Input float value, Output adjacent floating-point

System.out.println(Math.nextDown(gf));

double a = 0.0 / 0;

// Input NaN, Output NaN

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

float b = 0.0f;

// Input zero, Output - Float.MIN_VALUE for float

System.out.println(Math.nextDown(b));

double c = -1.0 / 0;

// Input negative infinity, Output negative infinity

System.out.println(Math.nextDown(c));

}

nextUp(double d)

nextUp(double d) – Retorna o valor do ponto flutuante adjacente a d na direção do infinito positivo.

public static double nextUp(double d) – Retorna o valor do ponto flutuante adjacente a d na direção do infinito positivo. Este método é semanticamente equivalente a nextAfter (d, Double.POSITIVE_INFINITY); no entanto, uma implementação nextUp pode ser executada mais rapidamente que sua chamada nextAfter equivalente.

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 zero, o resultado será Double.MIN_VALUE

Parâmetros:

d – iniciando o valor do ponto flutuante

Retornos:

O valor do ponto flutuante adjacente mais próximo do infinito positivo.

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

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

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get two double numbers
      double x = 98759.765;
      double y = 154.28764;
   
      // print the next floating numbers towards positive infinity
      System.out.println("Math.nextUp(" + x + ")=" + Math.nextUp(x));
      System.out.println("Math.nextUp(" + y + ")=" + Math.nextUp(y));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get two double numbers

double x = 98759.765;

double y = 154.28764;

// print the next floating numbers towards positive infinity

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

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

}

nextUp(float f)

nextUp(float f) – Retorna o valor do ponto flutuante adjacente a f na direção do infinito positivo.

public static float nextUp(float f) – Retorna o valor do ponto flutuante adjacente a f na direção do infinito positivo. Este método é semanticamente equivalente a nextAfter (f, Float.POSITIVE_INFINITY); no entanto, uma implementação nextUp pode ser executada mais rapidamente que sua chamada nextAfter equivalente.

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 zero, o resultado será Float.MIN_VALUE

Parâmetros:

f – iniciando o valor do ponto flutuante

Retornos:

O valor do ponto flutuante adjacente mais próximo do infinito positivo.

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

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

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

   public static void main(String[] args) {

      // get two float numbers
      float x = 98759.765f;
      float y = 154.28764f;
   
      // print the next floating numbers towards positive infinity
      System.out.println("Math.nextUp(" + x + ")=" + Math.nextUp(x));
      System.out.println("Math.nextUp(" + y + ")=" + Math.nextUp(y));
   }
}

package com.tutorialspoint;

import java.lang.*;

public class MathDemo {

public static void main(String[] args) {

// get two float numbers

float x = 98759.765f;

float y = 154.28764f;

// print the next floating numbers towards positive infinity

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

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

}

pow(double a, double b)

pow(double a, double b) – Retorna o valor do primeiro argumento elevado ao poder do segundo argumento.

public static double pow(double a, double b) – Retorna o valor do primeiro argumento elevado ao poder do segundo argumento. Casos especiais:

Se o segundo argumento for zero positivo ou negativo, o resultado será 1,0.
Se o segundo argumento for 1.0, o resultado será o mesmo que o primeiro argumento.
Se o segundo argumento for NaN, o resultado será NaN.
Se o primeiro argumento for NaN e o segundo argumento for diferente de zero, o resultado será NaN.
E se
o valor absoluto do primeiro argumento é maior que 1 e o segundo argumento é infinito positivo, ou
o valor absoluto do primeiro argumento é menor que 1 e o segundo argumento é infinito negativo,
então o resultado é infinito positivo.
E se
o valor absoluto do primeiro argumento é maior que 1 e o segundo argumento é infinito negativo, ou
o valor absoluto do primeiro argumento é menor que 1 e o segundo argumento é infinito positivo,
então o resultado é zero positivo.
Se o valor absoluto do primeiro argumento for igual a 1 e o segundo argumento for infinito, o resultado será NaN.
E se
o primeiro argumento é zero positivo e o segundo argumento é maior que zero, ou
o primeiro argumento é infinito positivo e o segundo argumento é menor que zero,
então o resultado é zero positivo.
E se
o primeiro argumento é zero positivo e o segundo argumento é menor que zero, ou
o primeiro argumento é infinito positivo e o segundo argumento é maior que zero,
então o resultado é infinito positivo.
E se
o primeiro argumento é zero negativo e o segundo argumento é maior que zero, mas não um número inteiro ímpar finito, ou
o primeiro argumento é infinito negativo e o segundo argumento é menor que zero, mas não um número inteiro ímpar finito,
então o resultado é zero positivo.
E se
o primeiro argumento é zero negativo e o segundo argumento é um número inteiro ímpar finito positivo, ou
o primeiro argumento é infinito negativo e o segundo argumento é um número inteiro ímpar finito negativo,
então o resultado é zero negativo.
E se
o primeiro argumento é zero negativo e o segundo argumento é menor que zero, mas não um número inteiro ímpar finito, ou
o primeiro argumento é infinito negativo e o segundo argumento é maior que zero, mas não um número inteiro ímpar finito,
então o resultado é infinito positivo.
E se
o primeiro argumento é zero negativo e o segundo argumento é um número inteiro ímpar finito negativo, ou
o primeiro argumento é infinito negativo e o segundo argumento é um número inteiro ímpar finito positivo,
então o resultado é infinito negativo.
Se o primeiro argumento for finito e menor que zero
se o segundo argumento for um número inteiro par finito, o resultado será igual ao resultado do aumento do valor absoluto do primeiro argumento à potência do segundo argumento
se o segundo argumento for um número inteiro ímpar finito, o resultado será igual ao negativo do resultado do aumento do valor absoluto do primeiro argumento à potência do segundo argumento
se o segundo argumento for finito e não um número inteiro, o resultado será NaN.
Se os dois argumentos forem números inteiros, o resultado será exatamente igual ao resultado matemático de elevar o primeiro argumento à potência do segundo argumento, se esse resultado puder de fato ser representado exatamente como um valor duplo.

(Nas descrições anteriores, um valor de ponto flutuante é considerado um número inteiro se e somente se for finito e um ponto fixo do teto do método ou, equivalentemente, um ponto fixo do piso do método. Um valor é um ponto fixo de um método de um argumento, se e somente se o resultado da aplicação do método ao valor for igual ao valor.)

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

Parâmetros:

a – a base.
b – o expoente.

Retornos:

o valor a^b.

Fonte do código: https://javatutorialhq.com/java/lang/math-class-tutorial-2/pow-method-example/

package com.javatutorialhq.java.examples;

import static java.lang.System.*;

import java.util.Scanner;

/*
 * This example source code demonstrates the use of 
 * power(double a,double b) method of Math class
 * Get the result of raising the base number to exponent
 */

public class MathPower {

	public static Scanner scan;
	public static void main(String[] args) {
		// ask for user input
		out.print("Enter the base number:");
		scan = new Scanner(System.in);
		// use scanner to get user console input, base
		double baseNumber = scan.nextDouble();
		// use scanner to get user console input, exponent
		out.print("Enter the exponent:");
		scan = new Scanner(System.in);
		double exponent = scan.nextDouble();		
		// get the result
		double result = Math.pow(baseNumber, exponent);		
		out.println("Result = "+result);		
		// close the scanner object to avoid memory leak
		scan.close();

	}

}

package com.javatutorialhq.java.examples;

import static java.lang.System.*;

import java.util.Scanner;

* This example source code demonstrates the use of

* power(double a,double b) method of Math class

* Get the result of raising the base number to exponent

public class MathPower {

public static Scanner scan;

public static void main(String[] args) {

// ask for user input

out.print("Enter the base number:");

scan = new Scanner(System.in);

// use scanner to get user console input, base

double baseNumber = scan.nextDouble();

// use scanner to get user console input, exponent

out.print("Enter the exponent:");

scan = new Scanner(System.in);

double exponent = scan.nextDouble();

// get the result

double result = Math.pow(baseNumber, exponent);

out.println("Result = "+result);

// close the scanner object to avoid memory leak

scan.close();

}

random()

random() – Retorna um valor duplo com um sinal positivo, maior ou igual a 0,0 e menor que 1,0.

public static double random() – Retorna um valor duplo com um sinal positivo, maior ou igual a 0,0 e menor que 1,0. Os valores retornados são escolhidos pseudo-aleatoriamente com (aproximadamente) distribuição uniforme desse intervalo.

Quando esse método é chamado pela primeira vez, ele cria um único novo gerador de números pseudo-aleatórios, exatamente como se fosse pela expressão

new java.util.Random()

Esse novo gerador de número pseudo-aleatório é usado posteriormente para todas as chamadas para esse método e não é usado em nenhum outro lugar.

Este método está sincronizado corretamente para permitir o uso correto por mais de um thread. No entanto, se muitos encadeamentos precisarem gerar números pseudo-aleatórios a uma grande velocidade, isso poderá reduzir a contenção de cada encadeamento para ter seu próprio gerador de número pseudo-aleatório.

Notas da API:

Como o maior valor duplo menor que 1,0 é Math.nextDown (1.0), um valor x no intervalo fechado [x1, x2] onde x1 <= x2 pode ser definido pelas instruções

 double f = Math.random()/Math.nextDown(1.0);
 double x = x1*(1.0 - f) + x2*f;

1 2	double f = Math.random()/Math.nextDown(1.0); double x = x1(1.0 - f) + x2f;

Retornos:

um pseudoaleatório duplo maior que ou igual a 0,0 e menor que 1,0.

Veja também:

nextDown(double), Random.nextDouble()

Fonte do código: http://www.bosontreinamentos.com.br/java/como-gerar-numeros-aleatorios-em-java-com-java-util-random-e-math-random/

<strong>// Gerando 5 números aleatórios inteiros entre 1 e 10 com Math.random:</strong>
<strong>import java.lang.Math;</strong>
<strong>public class aleatorio {</strong>
<strong>   public static void main(String args[]) </strong><strong>{</strong>
<strong>     // Gerar os 5 números aleatórios e mostrá-los:</strong>
<strong>     for (int i = 0; i &lt; 5; i++) {</strong>
<strong>        int numAleatorio = (int)(Math.random() * 10 ) + 1;</strong>
<strong>        System.out.println("Número: " + numAleatorio);</strong>
<strong>     }</strong>
<strong>   }</strong>
<strong>}</strong>

// Gerando 5 números aleatórios inteiros entre 1 e 10 com Math.random:

import java.lang.Math;

public class aleatorio {

public static void main(String args[]) {

// Gerar os 5 números aleatórios e mostrá-los:

for (int i = 0; i < 5; i++) {

int numAleatorio = (int)(Math.random() * 10 ) + 1;

System.out.println("Número: " + numAleatorio);

}

}

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

negateExact(long a)

nextAfter(double start, double direction)

nextAfter(float start, double direction)

nextDown(double d)

nextDown(float f)

nextUp(double d)

nextUp(float f)

pow(double a, double b)

random()

Programação de Jogos com Ênfase em Resolução de Problemas

A Classe String Parte 8

Uma Estrutura Linear de Dados: ArrayList Vem a Calhar

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

negateExact​(long a)

nextAfter​(double start, double direction)

nextAfter​(float start, double direction)

nextDown​(double d)

nextDown​(float f)

nextUp​(double d)

nextUp​(float f)

pow​(double a, double b)

random()

Programação de Jogos com Ênfase em Resolução de Problemas

A Classe String Parte 8

Uma Estrutura Linear de Dados: ArrayList Vem a Calhar

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

negateExact(long a)

nextAfter(double start, double direction)

nextAfter(float start, double direction)

nextDown(double d)

nextDown(float f)

nextUp(double d)

nextUp(float f)

pow(double a, double b)