What are all the cases that can result in a NaN output?(in Java)

I am trying to make a random number generator that generates normally distributed numbers, I have a method CDF to calculate the CDF for any given x, then I have a method invNorm that uses Newton's method over 30 iterations that accepts a desired value and it finds x such that CDF(x)=desired.

This is the formula for estimation of CDF that ive implemented

This is the Newton's method formula I have used(on evaluation the denominator {\Phi '(x)} simplifies and can brought to the numerator

public double cdf(double x){
        double out=0;
        for(int k=0;k<30;k++){
            out+=Math.pow(-1,k)*Math.pow(x,(2*k)+1)/(Math.pow(2,k)*factorial(k)*((2*k)+1));
        }
        return 0.5+(out/Math.sqrt(2*Math.PI));
    }
    public double invNorm(double desired){
        double x=0;
        double dx;
        for(int i=0;i<30;i++){
            dx=(cdf(x)-desired)*Math.exp(x*x*0.5)*Math.sqrt(2*Math.PI);
            x-=dx;
        } 
        return x;
    }

But this code is giving a NaN 10% of the time. When I ran the code to create a array of 100 random numbers and including this line "while(Double.isNaN(arr[i])) arr[i]=Misc.invNorm(Math.random());" that reassigns arr[i] if it got evaluated to NaN, the code ran perfectly and gave 70% value between the first standard deviations, 97 between the second and 100 between the third.The cdf function is definitely not the problem as I checked the cdf function by printing an array of 100 with cdf of random numbers and not a single one of them was NaN, but invNorm does not have any division at all and all powers are integers and there are no trigonometric functions. I considered the possibility of Math.exp returning positive infinity and (cdf(x)-desired) returning 0,but e^450 is not positive infinity and cdf(x) being equal to the desired value is very rare.

While we are on the topic could someone also help me with the implementation of the recursive function for CDF? I tried implementing it like this, where cdf_n is the nth approximation, i consider x0=0, so CDF(x0)=0.5, but this gave NaN almost 60% of the time.

public double cdf_n(double x,int n){
        if(n==0){
            return 0.5;
        }
        else if(n==1){
            return 1/Math.sqrt(2*Math.PI);
        }
        else{
            return (2-n)*cdf_n(x, n-2);
        }
    }
    public double cdf(double x){
        int n=0;
        double out;
        double cdf=0;
        do{
            out=cdf_n(x,n)*Math.pow(x,n)/factorial(n);
            cdf+=out;
            n++;
        } while(Math.abs(out)>Math.pow(10.0,-15.0));
        return cdf;
    }  

This is the recursive formula

Possible Cases:

1. Division of zero by zero: When you divide zero by zero, the result is NaN.

2. Division of a non-zero number by zero: Dividing a non-zero number by zero also results in NaN.

3. Operations involving NaN: Any arithmetic operation involving NaN as an operand will produce NaN as the result.

4. Mathematical functions with undefined values: Some mathematical functions may have undefined values for certain inputs, resulting in NaN.

Also it's important to note that comparing a value with NaN using the == operator will always return false. Instead, use the e.g. Double.isNaN() method to check if a value is NaN.