NaN i Java

I Java står "NaN" for "Not a Number". Det er ikke en type undtagelse, snarere overraskende er datatypen for NaN også et tal. Men ofte, når novice programmører får det utilsigtet, bruger de det yderligere i deres beregninger. Derfor kan inkompatible datatyper i Java, når de bruges sammen, forårsage en smid fejl. Det ses også almindeligvis, at java.lang.ArithmeticException: / by zerodet betragtes som det samme som NaN. Java behandler dem begge forskelligt. Forvirrende nok? For din omfattende forståelse vil vi dissekere, hvordan disse er forskellige fra hinanden. I slutningen af denne artikel vil du lære om de mulige operationer, der ikke producerer et tal (nan), og nogle nemme måder at håndtere det på.

Hvad er NaN?

Så hvad er NaN? "NaN", som mange af jer har gættet, bruges til at repræsentere "Not a Number" i Java. Det er en speciel flydende kommaværdi til at angive overløb og fejl. Det genereres, når et flydende kommatal divideres med nul, eller hvis kvadratroden af et negativt tal beregnes. NaN i Java - 1

Tag for eksempel et kig på følgende uddrag.

public class NaN
{
    public static void main(String[]args)
    {
        System.out.println(0.0 / 0.0);	  //zero divided by zero
        System.out.println(Math.sqrt(-1)); //take sqrt of negative number
        System.out.println(10.0 % 0);      //taking mod by zero
    }
}

Produktion

NaN
NaN
NaN

I uddraget ovenfor kan du observere, at NaN produceres som et resultat af 3 simple operationer:

At dividere et float / doublenul med nul.
Under-roden af et negativt tal (Math.sqrt(-x)). I matematik resulterer det at tage kvadratroden af et negativt tal i et imaginært tal . Denne sag behandles ved at returnere NaN i Java.
Hvis du tager mod af et tal med nul, returneres resten efter at have divideret en værdi med nul. Derfor returneres NaN.

Hvordan er NaN forskellig fra positiv og negativ uendelighed?

I henhold til IEEE 754-specifikationen er der tre specielle flydende komma- og dobbeltværdier til at håndtere grænsetilfældene:

Positiv uendelighed
Negativ uendelighed
NaN

Resultatet af at dividere et positivt tal med 0 er positiv uendelighed. På samme måde giver negativ uendelighed som et resultat af at dividere et negativt tal med nul. Bemærk venligst, at alle flydende kommaværdier også gælder for datatypen dobbelt. Den begrænsede præcision af flydere er til tider ikke tilstrækkelig. Vi vil dog se, hvordan NaN virker for både float og double i et senere afsnit.

Hvad er NaN()-metoden?

isNaN()er en af de grundlæggende metoder i Java til at kontrollere, om det er en NaN-værdi eller ej. Som vi diskuterede tre tilfælde ovenfor, er det tid til at teste, hvordan isNaN()-metoden skelner mellem +infinity , -infinity og NaN-værdier.

public class isNaN
{ public static void main(String[]args)
  {
    Double posInfinity = +2.0 / 0.0;
    Double negInfinity = -3.5 / 0.0;
    Double nanVal = 50 % 0.0;


    System.out.println ("+" + posInfinity + ".IsNaN() = " + posInfinity.isNaN());
    System.out.println ( negInfinity + ".IsNaN() = " + negInfinity.isNaN());
    System.out.println ( nanVal +  ".IsNaN() = " + nanVal.isNaN());
  }
}

Produktion

+Infinity.IsNaN() = false
-Infinity.IsNaN() = false
NaN.IsNaN() = true

Hvordan sammenligner man NaN-værdier?

Hver NaN-værdi anses for at være særskilt. Det betyder, at ikke et enkelt NaN er lig med noget andet NaN. Ved dette princip, hvis du sammenligner en værdi med en anden, er resultatet altid negativt. Da NaN er uordnet, så en numerisk sammenligning, der involverer selv et enkelt NaN, returnerer falsk. Java giver Float.NaN og Double.NaN til konstante felter i begge klasser for at udføre sammenligninger. Vi kan skelne mellem disse i to separate scenarier:

Sandt: Kun i tilfælde af ulighed (!=)
Falsk: For alle sammenligningsoperander (==, <=, >=, <, >)

Her er et fungerende eksempel til jer:

public class ComparingNaN
{ public static void main(String[] args)
  {
    // Comparing NaN values for Float constants
    System.out.println (Float.NaN != Float.NaN); // true
    System.out.println (Float.NaN == Float.NaN); // false
    System.out.println (Float.NaN < Float.NaN);  // false
    System.out.println (Float.NaN > Float.NaN);  // false
    System.out.println (Float.NaN <= Float.NaN); // false
    System.out.println (Float.NaN >= Float.NaN); // false

    // Comparing NaN values for Float constants
    System.out.println (Double.NaN != Double.NaN); // true
    System.out.println (Double.NaN == Double.NaN); // false
    System.out.println (Double.NaN < Double.NaN);  // false
    System.out.println (Double.NaN > Double.NaN);  // false
    System.out.println (Double.NaN <= Double.NaN); // false
    System.out.println (Double.NaN >= Double.NaN); // false
  }
}

Hvordan genererer man NaN-værdier?

Inden vi afslutter, lad os se på nogle almindelige eksempler på at få et Not a Number (nan).

public class GenerateNaNValues {
  static final float ZERO = 0;
  public static void main (String[]args)
  {
    System.out.println("ZERO / ZERO = " + (ZERO / ZERO));
    System.out.println("+INFINITY - INFINITY = " +
    (Float.POSITIVE_INFINITY + Float.NEGATIVE_INFINITY));
    System.out.println("-INFINITY * ZERO = " + (Float.NEGATIVE_INFINITY * ZERO));
    System.out.println("+INFINITY * ZERO = " + (Float.POSITIVE_INFINITY * ZERO));
    System.out.println("log10(-10) = " +  Math.log(-10));
    System.out.println("√-10 = " + Math.sqrt(-10));
    System.out.println("NaN + 10 = " + (Float.NaN + 10));
    System.out.println("NaN - 10 = " + (Float.NaN - 10));
    System.out.println("NaN * 10 = " + (Float.NaN * 10));
    System.out.println("NaN / 10 = " + (Float.NaN / 10));
    System.out.println("NaN + NaN = " + (Float.NaN + Float.NaN));
    System.out.println("NaN - NaN = " + (Float.NaN - Float.NaN));
    System.out.println("NaN * NaN = " + (Float.NaN * Float.NaN));
    System.out.println("NaN / NaN = " + (Float.NaN / Float.NaN));
  }
}

Produktion:

ZERO / ZERO = NaN
+INFINITY - INFINITY = NaN
-INFINITY * ZERO = NaN
+INFINITY * ZERO = NaN
log10(-10) = NaN
√-10 = NaN
NaN + 10 = NaN
NaN - 10 = NaN
NaN * 10 = NaN
NaN / 10 = NaN
NaN + NaN = NaN
NaN - NaN = NaN
NaN * NaN = NaN
NaN / NaN = NaN

Konklusion

Efter at have set på de mange operationer, der producerer NaN, skal du være bekendt med det nu. Det kan måske undre dig i begyndelsen, men der er ikke noget kompliceret at håndtere dette. Ved at udvikle en lille vane med at tjekke, om en værdi ikke er NaN i dobbelt-/floating-point-beregninger, kan du spare dig for en masse besvær. Selvom du glemmer dette i starten, er det helt fint. Du kan altid konsultere denne artikel for mindre fejlfinding. Oprettelse af kompilerbar, fejlfri kode på én gang kommer efter mange års erfaring. Så lad os få snavsede hænder i kode og bygge noget fantastisk!