Java'da NaN

Java'da “NaN”, “Sayı Değil” anlamına gelir. Bu bir istisna türü değildir, oldukça şaşırtıcı bir şekilde, NaN'nin veri türü de bir sayıdır. Ancak genellikle acemi programcılar bunu istemeden anladıklarında, hesaplamalarında daha fazla kullanırlar. Bu nedenle, Java'daki uyumsuz veri türleri birlikte kullanıldığında fırlatılabilir bir hataya neden olabilir. java.lang.ArithmeticException: / by zeroNaN ile aynı kabul edildiği de yaygın olarak görülmektedir . Ancak, Java her ikisine de farklı davranır. Yeterince şaşırtıcı mı? Kapsamlı anlayışınız için, bunların birbirinden ne kadar farklı olduğunu inceleyeceğiz. Bu makalenin sonunda, bir sayı (nan) oluşturmayan olası işlemleri ve bununla başa çıkmanın bazı kolay yollarını öğreneceksiniz.

NaN nedir?

Peki, NaN nedir? Çoğunuzun tahmin ettiği gibi “NaN”, Java'da “Sayı Değil”i temsil etmek için kullanılır. Taşma ve hataları belirtmek için özel bir kayan nokta değeridir. Bir kayan noktalı sayı sıfıra bölündüğünde veya negatif bir sayının karekökü hesaplandığında üretilir. Örneğin, aşağıdaki parçacığa bir göz atın.

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

Çıktı

NaN                                                                                                                                           
NaN                                                                                                                                           
NaN

Yukarıdaki snippet'te, NaN'nin 3 basit işlem sonucunda üretildiğini gözlemleyebilirsiniz:

• float / doubleSıfırı sıfıra bölmek .
• Negatif bir sayının kökünün alınması (Math.sqrt(-x)). Matematikte, negatif bir sayının karekökü alındığında hayali bir sayı elde edilir . Bu durum Java'da NaN döndürülerek çözülür.
• Sıfır olan bir sayının modunu almak, bir değeri sıfıra böldükten sonra kalanı döndürür. Bu nedenle, NaN döndürülür.

NaN'nin Pozitif ve Negatif Sonsuzdan Farkı Nedir?

IEEE 754 spesifikasyonuna göre, sınır durumlarını işlemek için üç özel kayan nokta ve çift değer vardır:

• pozitif sonsuzluk
• negatif sonsuzluk
• NaN

Pozitif bir sayıyı 0'a bölmenin sonucu pozitif sonsuzdur. Benzer şekilde, negatif bir sayının sıfıra bölünmesi sonucunda negatif sonsuz elde edilir. Lütfen tüm kayan nokta değerlerinin double veri türü için de geçerli olduğunu unutmayın. Şamandıraların sınırlı hassasiyeti bazen yeterli değildir. Ancak, sonraki bir bölümde NaN'nin hem float hem de double için nasıl çalıştığını göreceğiz.

NaN() Yöntemi nedir?

isNaN()NaN değeri olup olmadığını kontrol etmek için Java'daki temel yöntemlerden biridir. Yukarıda üç durumu tartıştığımız gibi, isNaN() yönteminin +infinity , -infinity ve NaN değerleri arasında nasıl ayrım yaptığını test etmenin zamanı geldi.

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

Çıktı

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

NaN Değerleri Nasıl Karşılaştırılır?

Her NaN değeri ayrı kabul edilir. Bu, tek bir NaN'nin başka hiçbir NaN'ye eşit olmadığı anlamına gelir. Bu ilkeye göre, bir değeri başka bir değerle karşılaştırırsanız sonuç her zaman negatiftir. NaN sırasız olduğundan, tek bir NaN içeren sayısal bir karşılaştırma bile yanlış döndürür. Java, karşılaştırma yapmak için her iki sınıfta da sabit alanlar için Float.NaN ve Double.NaN sağlar. Bunları iki ayrı senaryoda ayırt edebiliriz:

• Doğru: Yalnızca eşitsizlik durumunda (!=)
• Yanlış: Tüm karşılaştırma işlenenleri için (==, <=, >=, <, >)

İşte size çalışan bir örnek arkadaşlar:

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

NaN Değerleri Nasıl Üretilir?

Bitirmeden önce, Sayı Değil (nan) almanın bazı yaygın örneklerine bakalım.

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

Çıktı:

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

Çözüm

NaN üreten sayısız operasyona baktıktan sonra, artık buna aşina olmalısınız. Başlangıçta kafanızı karıştırabilir, ancak bununla uğraşırken karmaşık bir şey yoktur. Çift/kayan noktalı hesaplamalarda bir değerin NaN olup olmadığını kontrol etme alışkanlığını geliştirmek, sizi pek çok zahmetten kurtarabilir. Bunu başlangıçta unutsanız bile, tamamen sorun değil. Küçük sorun giderme için her zaman bu makaleye başvurabilirsiniz. Tek seferde derlenebilir, hatasız kod oluşturmak, yılların deneyiminden sonra gelir. O halde ellerimizi kodla kirletelim ve harika bir şey inşa edelim!