public static Ptg calcNormsInv( Ptg[] operands )
	{
		if( operands.length != 1 )
		{
			return PtgCalculator.getValueError();
		}
		try
		{
			double x = operands[0].getDoubleVal();
			if( (x < 0) || (x > 1) )
			{
				return new PtgErr( PtgErr.ERROR_NUM );
			}
		 /*
		  * the algorithm is supposed to iterate over NORMSDIST values using Newton-Raphson's approximation
		  * Newton-Raphson uses an iterative process to approach one root of a function (i.e the zero of the function or 
		  * where the function = 0) 
		  * Newton-Raphson is in the form of:
		  * 
		  * Xn+1= Xn- (f(xn)/f'(xn)
		  * where Xn is the current known X value, f(xn) is the value of the function at X, f'(Xn) is the derivative or slope
		  * at X, Xn+1 is the next X value. Essentially, f'(xn) represents (f(x)/delta x) so f(xn)/f'(xn)== delta x.
		  * the more iterations we run over, the closer delta x will be to 0.
		  * 
		  * The Newton-Raphson method does not always work, however. It runs into problems in several places. 
			What would happen if we chose an initial x-value of x=0? We would have a "division by zero" error, and would not be able to proceed. 
			You may also consider operating the process on the function f(x) = x1/3, using an inital x-value of x=1. 
			Do the x-values converge? Does the delta-x decrease toward zero (0)?
			
			 is the derivative of the standard normal distribution = the standard probability density function???
		  */
/* below is not accurate enough - but N-R approximation is impossible ((:*/
			// Coefficients in rational approximations
			double[] a = new double[]{
					-3.969683028665376e+01,
					2.209460984245205e+02,
					-2.759285104469687e+02,
					1.383577518672690e+02,
					-3.066479806614716e+01,
					2.506628277459239e+00
			};

			double[] b = new double[]{
					-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, -1.328068155288572e+01
			};

			double[] c = new double[]{
					-7.784894002430293e-03,
					-3.223964580411365e-01,
					-2.400758277161838e+00,
					-2.549732539343734e+00,
					4.374664141464968e+00,
					2.938163982698783e+00
			};

			double[] d = new double[]{
					7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00
			};

			// Define break-points.
			double plow = 0.02425;
			double phigh = 1 - plow;
			double result;
			// Rational approximation for lower region:
			if( x < plow )
			{
				double q = Math.sqrt( -2 * Math.log( x ) );
				BigDecimal r = new BigDecimal( ((((((((((c[0] * q) + c[1]) * q) + c[2]) * q) + c[3]) * q) + c[4]) * q) + c[5]) / ((((((((d[0] * q) + d[1]) * q) + d[2]) * q) + d[3]) * q) + 1) );
				r.setScale( 15, java.math.RoundingMode.HALF_UP );
				return new PtgNumber( r.doubleValue() );
			}

			// Rational approximation for upper region:
			if( phigh < x )
			{
				double q = Math.sqrt( -2 * Math.log( 1 - x ) );
				BigDecimal r = new BigDecimal( -((((((((((c[0] * q) + c[1]) * q) + c[2]) * q) + c[3]) * q) + c[4]) * q) + c[5]) / ((((((((d[0] * q) + d[1]) * q) + d[2]) * q) + d[3]) * q) + 1) );
				r.setScale( 15, java.math.RoundingMode.HALF_UP );
				return new PtgNumber( r.doubleValue() );
			}

			// Rational approximation for central region:
			double q = x - 0.5;
			double r = q * q;
			BigDecimal rr = new BigDecimal( (((((((((((a[0] * r) + a[1]) * r) + a[2]) * r) + a[3]) * r) + a[4]) * r) + a[5]) * q) / ((((((((((b[0] * r) + b[1]) * r) + b[2]) * r) + b[3]) * r) + b[4]) * r) + 1) );

			rr.setScale( 15, java.math.RoundingMode.HALF_UP );
			return new PtgNumber( rr.doubleValue() );
		}
		catch( Exception e )
		{
			return PtgCalculator.getValueError();
		}
	}