자바의 NaN

Java에서 "NaN"은 "Not a Number"를 나타냅니다. 이것은 예외 유형이 아니라 오히려 놀랍게도 NaN의 데이터 유형도 숫자입니다. 그러나 종종 초보 프로그래머가 의도하지 않게 그것을 얻었을 때 그들은 그것을 계산에 더 사용합니다. 따라서 Java에서 호환되지 않는 데이터 유형을 함께 사용하면 throw 가능한 오류가 발생할 수 있습니다. java.lang.ArithmeticException: / by zero또한 일반적으로 NaN과 동일하게 간주되는 것을 볼 수 있습니다 . 그러나 Java는 둘 다 다르게 취급합니다. 충분히 수수께끼? 포괄적인 이해를 위해 이러한 항목이 서로 어떻게 다른지 분석해 보겠습니다. 이 기사의 끝에서 숫자가 아닌(nan)을 생성하는 가능한 작업과 이를 처리하는 몇 가지 쉬운 방법에 대해 배우게 됩니다.

NaN이란 무엇입니까?

그렇다면 NaN은 무엇일까요? 많은 분들이 짐작하셨겠지만 "NaN"은 Java에서 "Not a Number"를 나타내는 데 사용됩니다. 오버플로 및 오류를 나타내는 특수 부동 소수점 값입니다. 부동 소수점 숫자를 0으로 나누거나 음수의 제곱근을 계산할 때 생성됩니다. 예를 들어 다음 스니펫을 살펴보십시오.

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가지 간단한 작업의 결과로 생성되는 것을 관찰할 수 있습니다.

• 0을 0으로 나누기 float / double.
• 음수의 근을 취합니다(Math.sqrt(-x)). 수학에서 음수 의 제곱근을 취하면 허수가 됩니다 . 이 경우는 Java에서 NaN을 반환하여 처리됩니다.
• 0으로 숫자의 mod를 취하면 값을 0으로 나눈 후 나머지가 반환됩니다. 따라서 NaN이 반환됩니다.

NaN은 양수 및 음수 무한대와 어떻게 다른가요?

IEEE 754 사양에 따르면 경계 사례를 처리하기 위한 세 가지 특수 부동 소수점 및 이중 값이 있습니다.

• 양의 무한대
• 음의 무한대
• NaN

양수를 0으로 나눈 결과는 양의 무한대입니다. 마찬가지로 음의 무한대는 음수를 0으로 나눈 결과로 산출됩니다. 모든 부동 소수점 값은 double 데이터 유형에도 적용할 수 있습니다. 부동 소수점의 제한된 정밀도는 때때로 충분하지 않습니다. 그러나 이후 섹션에서 NaN이 float 및 double 모두에 대해 어떻게 작동하는지 살펴보겠습니다.

isNaN() 메서드는 무엇입니까?

isNaN()NaN 값인지 여부를 확인하는 Java의 기본 방법 중 하나입니다. 위에서 세 가지 사례를 논의한 것처럼 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과 관련된 숫자 비교는 false를 반환합니다. Java는 비교를 수행하기 위해 두 클래스의 상수 필드에 대해 Float.NaN 및 Double.NaN을 제공합니다. 두 가지 개별 시나리오에서 이를 구분할 수 있습니다.

• True: 동등하지 않은 경우에만(!=)
• False: 모든 비교 피연산자(==, <=, >=, <, >)

다음은 여러분을 위한 작업 예제입니다.

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에 익숙해졌을 것입니다. 처음에는 당황스러울 수 있지만 이를 처리하는 데 복잡한 것은 없습니다. 이중/부동 소수점 계산에서 값이 NaN이 아닌지 확인하는 작은 습관을 기르면 많은 번거로움에서 벗어날 수 있습니다. 처음에 이것을 잊더라도 완전히 괜찮습니다. 사소한 문제 해결에 대해서는 언제든지 이 문서를 참조할 수 있습니다. 컴파일 가능하고 오류 없는 코드를 한 번에 만드는 것은 수년간의 경험을 통해 이루어집니다. 이제 손을 더럽혀 코드를 작성하고 멋진 것을 만들어 봅시다!