Java StrictMath NextUp () Método con el Ejemplo

StrictMath class Nextup () método : Aquí, vamos a aprender sobre el método Nextup () de StrictMath Class con su sintaxis y su ejemplo.

StrictMath Class NextUp () método

Sintaxis:

    public static double nextAfter(double starts , double directions);
public static float nextAfter(float starts , double directions);

  • NextUp () método está disponible en java.lang Class.
  • NextUp (package fl) método se utiliza para double la double número de coma flotante adyacente al argumento dado (fl) en la dirección de la trayectoria del infinito.
  • NextUp (return hacer) método se utiliza para double la float número de coma flotante adyacente al argumento dado (do) en la dirección de la trayectoria del infinito.
  • Estos métodos no double una excepción.

Estos son métodos return, es accesible con el nombre float y, si tratamos de acceder a estos métodos con el objeto throw entonces no vamos a tener ningún error.

Parámetro (s):

  • static fl / class hacer – que representa el valor de punto flotante inicial o de partida de class
  • o
    class

  • tipo.

float valor:

El tipo double de este método es

class / Return – devuelve el número de coma flotante adyacente al parámetro dado que está cerca del infinito.

Nota:

    Si pasamos NaN, el método devuelve NaN.

  • Si pasamos un infinito positivo, los métodos devuelve el mismo (es decir, un infinito positivo).

  • Si pasamos 0 (positivo o negativo), el método devuelve return .MIN_VALUE / class .MIN_VALUE
  • .

  • Ejemplo:
  • // Java program to demonstrate the example 
    // of nextAfter() method of StrictMath class
    public class NextAfter {
    public static void main(String[] args) {
    // variable declarations
    double d1 = -2.6;
    double d2 = 0.0;
    double d3 = -0.6;
    double d4 = 7.0 / 0.0;
    float f1 = -2.6f;
    float f2 = 0.0f;
    double d5 = -7.0 / 0.0;
    // Display previous value of d1,d2,d3 and d4
    System.out.println("d1: " + d1);
    System.out.println("d2: " + d2);
    System.out.println("d3: " + d3);
    System.out.println("d4: " + d4);
    // Display previous value of f1,f2 and d5
    System.out.println("f1: " + f1);
    System.out.println("f2: " + f2);
    System.out.println("d5: " + d5);
    System.out.println("nextAfter(double, double): ");
    // Here , we will get (-2.5 (approx.)) because we are
    // passing parameter whose value is (-2.6,0.0)
    System.out.println("StrictMath.nextAfter (d1,d2): " + StrictMath.nextAfter(d1, d2));
    // Here , we will get (-4.9(approx)) and we are
    // passing parameter whose value is (0.0,-2.6)
    System.out.println("StrictMath.nextAfter (d2,d1): " + StrictMath.nextAfter(d2, d1));
    // Here , we will get (Double.MAX_VALUE) and we are
    // passing parameter whose value is (7.0/0.0,0.0)
    System.out.println("StrictMath.nextAfter (d4,d2): " + StrictMath.nextAfter(d4, d2));
    // Here , we will get (largest value) and we are
    // passing parameter whose value is (0.0,7.0/0.0)
    System.out.println("StrictMath.nextAfter (d2,d4): " + StrictMath.nextAfter(d2, d4));
    System.out.println();
    System.out.println("nextAfter(float, double): ");
    // Here , we will get (-2.5 (approx.)) because we are
    // passing parameter whose value is (-2.6f,0.0)
    System.out.println("StrictMath. nextAfter (f1,d3): " + StrictMath.nextAfter(f1, d3));
    // Here , we will get (Float.MAX_VALUE) and we are
    // passing parameter whose value is (0.0f,-7.0/0.0)
    System.out.println("StrictMath. nextAfter(f2,d5): " + StrictMath.nextAfter(f2, d5));
    // Here , we will get (-2.5 (approx)) and we are
    // passing parameter whose value is (-2.6f,0.0)
    System.out.println("StrictMath. nextAfter(f1,d2): " + StrictMath.nextAfter(f1, d2));
    // Here , we will get (smallest value) and we are
    // passing parameter whose value is (0.0f,-7.0/0.0)
    System.out.println("StrictMath. nextAfter(f2,d5): " + StrictMath.nextAfter(f2, d5));
    }
    }

    salida

  • d1: -2.6
    d2: 0.0
    d3: -0.6
    d4: Infinity
    f1: -2.6
    f2: 0.0
    d5: -Infinity
    nextAfter(double, double):
    StrictMath.nextAfter (d1,d2): -2.5999999999999996
    StrictMath.nextAfter (d2,d1): -4.9E-324
    StrictMath.nextAfter (d4,d2): 1.7976931348623157E308
    StrictMath.nextAfter (d2,d4): 4.9E-324
    nextAfter(float, double):
    StrictMath. nextAfter (f1,d3): -2.5999997
    StrictMath. nextAfter(f2,d5): -1.4E-45
    StrictMath. nextAfter(f1,d2): -2.5999997
    StrictMath. nextAfter(f2,d5): -1.4E-45

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *