NaN في جاوة

في جافا، يشير "NaN" إلى "ليس رقمًا". إنه ليس نوعًا من الاستثناء، بل من المدهش أن نوع بيانات NaN هو أيضًا رقم. ولكن في كثير من الأحيان عندما يحصل المبرمجون المبتدئون على هذه المعلومة عن غير قصد، فإنهم يستخدمونها أيضًا في حساباتهم. ومن ثم، فإن أنواع البيانات غير المتوافقة في Java عند استخدامها معًا يمكن أن تتسبب في حدوث خطأ يمكن التخلص منه. ومن الشائع أيضًا أن java.lang.ArithmeticException: / by zeroيعتبر نفس NaN. ومع ذلك، تتعامل Java معهما بشكل مختلف. محير بما فيه الكفاية؟ من أجل فهمك الشامل، سنقوم بتحليل كيفية اختلاف هذه العناصر عن بعضها البعض. في نهاية هذه المقالة ستتعرف على العمليات الممكنة التي لا تنتج رقمًا (نان)، وبعض الطرق السهلة للتعامل معها.

ما هو نان؟

إذًا، ما هو NaN؟ يتم استخدام "NaN" كما خمن الكثير منكم لتمثيل "ليس رقمًا" في Java. إنها قيمة فاصلة عائمة خاصة للإشارة إلى التجاوزات والأخطاء. يتم إنشاؤه عندما يتم قسمة رقم الفاصلة العائمة على صفر أو إذا تم حساب الجذر التربيعي لعدد سالب. على سبيل المثال، ألق نظرة على المقتطف التالي.

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 يتم إنتاجه نتيجة لثلاث عمليات بسيطة:

• قسمة float / doubleالصفر على صفر.
• أخذ جذر الرقم السالب (Math.sqrt(-x)). في الرياضيات، يؤدي أخذ الجذر التربيعي لعدد سالب إلى الحصول على عدد وهمي . يتم التعامل مع هذه الحالة عن طريق إرجاع NaN في Java.
• سيؤدي أخذ تعديل رقم بصفر إلى إرجاع الباقي بعد قسمة القيمة على صفر. وبالتالي، يتم إرجاع NaN.

كيف يختلف NaN عن اللانهاية الإيجابية والسلبية؟

وفقًا لمواصفات IEEE 754، هناك ثلاث قيم خاصة للفاصلة العائمة والمزدوجة للتعامل مع الحالات الحدودية:

• اللانهاية الإيجابية
• اللانهاية السلبية
• نان

نتيجة قسمة عدد موجب على 0 هي ما لا نهاية موجبة. وبالمثل، فإن اللانهاية السالبة تنتج نتيجة قسمة عدد سالب على صفر. يرجى ملاحظة أن جميع قيم الفاصلة العائمة تنطبق على نوع البيانات المزدوج أيضًا. الدقة المحدودة للعوامات ليست كافية في بعض الأحيان. ومع ذلك، سنرى كيف يعمل NaN لكل من التعويم والمزدوج في قسم لاحق.

ما هي طريقة NaN ()؟

isNaN()هي إحدى الطرق الأساسية في Java للتحقق مما إذا كانت قيمة 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 واحدة تُرجع خطأ. توفر Java 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؟

قبل الختام، دعونا نلقي نظرة على بعض الأمثلة الشائعة للحصول على ليس رقمًا (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 في حسابات النقطة المزدوجة/العائمة، يمكن أن يوفر عليك الكثير من المتاعب. حتى لو نسيت هذا في البداية، فلا بأس تمامًا. يمكنك دائمًا الرجوع إلى هذه المقالة لاستكشاف الأخطاء وإصلاحها البسيطة. يأتي إنشاء تعليمات برمجية قابلة للتجميع وخالية من الأخطاء دفعة واحدة بعد سنوات من الخبرة. لذلك دعونا نتعلم البرمجة، ونبني شيئًا رائعًا!