جاوا میں NaN

جاوا میں، "NaN" کا مطلب ہے "نمبر نہیں"۔ یہ ایک قسم کی رعایت نہیں ہے، بلکہ حیرت انگیز طور پر، NaN کا ڈیٹا ٹائپ بھی ایک نمبر ہے۔ لیکن اکثر جب نوآموز پروگرامرز اسے غیر ارادی طور پر حاصل کرتے ہیں، تو وہ اسے اپنے حساب کتاب میں مزید استعمال کرتے ہیں۔ لہذا، جاوا میں غیر مطابقت پذیر ڈیٹا کی قسمیں جب ایک ساتھ استعمال ہوتی ہیں تو پھینکنے کے قابل غلطی کا سبب بن سکتی ہیں۔ یہ بھی عام طور پر دیکھا جاتا ہے جسے java.lang.ArithmeticException: / by zeroNaN جیسا ہی سمجھا جاتا ہے۔ تاہم، جاوا ان دونوں کے ساتھ مختلف سلوک کرتا ہے۔ کافی puzzling؟ آپ کی جامع تفہیم کے لیے ہم اس بات کا تجزیہ کریں گے کہ یہ ایک دوسرے سے کیسے مختلف ہیں۔ اس مضمون کے اختتام تک آپ ان ممکنہ کارروائیوں کے بارے میں جانیں گے جو نمبر (nan) نہیں بناتے ہیں، اور اسے سنبھالنے کے کچھ آسان طریقے۔

NaN کیا ہے؟

تو، NaN کیا ہے؟ "NaN" جیسا کہ آپ میں سے بہت سے لوگوں نے اندازہ لگایا ہے، جاوا میں "نمبر نہیں" کی نمائندگی کرنے کے لیے استعمال ہوتا ہے۔ یہ اوور فلو اور غلطیوں کو ظاہر کرنے کے لیے ایک خاص فلوٹنگ پوائنٹ ویلیو ہے۔ یہ اس وقت پیدا ہوتا ہے جب ایک فلوٹنگ پوائنٹ نمبر کو صفر سے تقسیم کیا جاتا ہے یا اگر کسی منفی نمبر کی مربع جڑ کی گنتی کی جاتی ہے۔ مثال کے طور پر، درج ذیل ٹکڑوں پر ایک نظر ڈالیں۔

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

آؤٹ پٹ

NaN                                                                                                                                           
NaN                                                                                                                                           
NaN

اوپر کے ٹکڑوں میں، آپ دیکھ سکتے ہیں کہ NaN 3 آسان آپریشنز کے نتیجے میں تیار ہوتا ہے:

• float / doubleصفر کو صفر سے تقسیم کرنا ۔
• منفی نمبر (Math.sqrt(-x)) کا انڈر روٹ لینا۔ ریاضی میں، منفی نمبر کا مربع جڑ لینے سے خیالی نمبر بنتا ہے ۔ یہ کیس جاوا میں NaN کو واپس کرکے نمٹا جاتا ہے۔
• صفر کے ساتھ کسی عدد کا موڈ لینا، قدر کو صفر سے تقسیم کرنے کے بعد بقیہ کو لوٹائے گا۔ لہذا، NaN واپس آ گیا ہے۔

NaN مثبت اور منفی انفینٹی سے کیسے مختلف ہے؟

IEEE 754 تفصیلات کے مطابق، باؤنڈری کیسز کو ہینڈل کرنے کے لیے تین خصوصی فلوٹنگ پوائنٹ اور ڈبل ویلیوز ہیں:

• مثبت انفینٹی
• منفی انفینٹی
• NaN

مثبت نمبر کو 0 سے تقسیم کرنے کا نتیجہ مثبت انفینٹی ہے۔ اسی طرح، منفی عدد کو صفر کے ساتھ تقسیم کرنے کے نتیجے میں منفی انفینٹی حاصل ہوتی ہے۔ براہ کرم نوٹ کریں کہ تمام فلوٹنگ پوائنٹ ویلیوز ڈیٹا ٹائپ ڈبل پر بھی لاگو ہوتی ہیں۔ فلوٹس کی محدود درستگی بعض اوقات کافی نہیں ہوتی ہے۔ تاہم، ہم دیکھیں گے کہ بعد کے حصے میں NaN فلوٹ اور ڈبل دونوں کے لیے کیسے کام کرتا ہے۔

NaN() طریقہ کیا ہے؟

isNaN()جاوا میں بنیادی طریقوں میں سے ایک ہے یہ چیک کرنے کے لیے کہ آیا یہ NaN ویلیو ہے یا نہیں۔ جیسا کہ ہم نے اوپر تین معاملات پر تبادلہ خیال کیا ہے، یہ جانچنے کا وقت ہے کہ کس طرح isNaN() طریقہ +infinity ، -infinity اور NaN اقدار کے درمیان فرق کرتا ہے۔

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

آؤٹ پٹ

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

NaN اقدار کا موازنہ کیسے کریں؟

ہر NaN قدر کو الگ سمجھا جاتا ہے۔ اس کا مطلب ہے، ایک بھی NaN کسی دوسرے NaN کے برابر نہیں ہے۔ اس اصول کے مطابق، اگر آپ ایک قدر کا دوسری سے موازنہ کرتے ہیں تو نتیجہ ہمیشہ منفی ہوتا ہے۔ چونکہ، NaN غیر ترتیب شدہ ہے، اس لیے ایک عددی موازنہ جس میں ایک NaN بھی شامل ہے غلط لوٹاتا ہے۔ جاوا موازنہ کرنے کے لیے دونوں کلاسوں میں مستقل فیلڈز کے لیے Float.NaN اور Double.NaN فراہم کرتا ہے۔ ہم ان کو دو الگ الگ منظرناموں میں الگ کر سکتے ہیں:

• درست: صرف مساوات کی صورت میں (!=)
• غلط: تمام موازنہ آپرینڈز کے لیے (==, <=, >=, <, >)

یہاں آپ لوگوں کے لئے ایک کام کرنے والی مثال ہے:

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 قدریں کیسے بنائیں؟

سمیٹنے سے پہلے، آئیے 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));
  }
}

آؤٹ پٹ:

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

نتیجہ

NaN پیدا کرنے والے متعدد آپریشنز کو دیکھنے کے بعد، آپ کو اب اس سے واقف ہونا چاہیے۔ یہ آپ کو ابتدائی طور پر پریشان کر سکتا ہے، لیکن اس سے نمٹنے میں کوئی پیچیدہ چیز نہیں ہے۔ یہ چیک کرنے کی تھوڑی سی عادت ڈالنے سے کہ آیا ڈبل/فلوٹنگ پوائنٹ کیلکولیشن میں کوئی قدر NaN نہیں ہے آپ کو بہت زیادہ پریشانی سے بچا سکتا ہے۔ یہاں تک کہ اگر آپ اسے ابتدائی طور پر بھول جاتے ہیں، تو یہ بالکل ٹھیک ہے۔ معمولی خرابیوں کا سراغ لگانے کے لیے آپ ہمیشہ اس مضمون سے مشورہ کر سکتے ہیں۔ ایک بار میں مرتب کرنے کے قابل، غلطی سے پاک کوڈ بنانا سالوں کے تجربے کے بعد آتا ہے۔ تو آئیے اپنے ہاتھوں کو کوڈ میں گندا کریں، اور کچھ عظیم بنائیں!