import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * Computes the significance of the difference between two correlations.
 * @see org.tud.sir.util.statistics.Significance.testCorrelations
 */
public static double getSignificance(double correlation1, double correlation2, int n1, int n2) throws MathException {
    
    // transform to Fisher Z-values
    double zv1 = FisherZTransformation.transform(correlation1);
    double zv2 = FisherZTransformation.transform(correlation2);

    // difference of the Z-values
    double zDifference = (zv1 - zv2) / Math.sqrt(2d) / Math.sqrt( (double)1/(n1-3) + (double)1/(n2-3));
    
    // get p value from the complementary error function
    double p = Erf.erfc( Math.abs(zDifference));
    return p;
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * Computes the relative probability of receiving a photon at the pixel. 
 * @param pixelX The pixel's x-position.
 * @param pixelY The pixel's y-position.
 * @return The probability of a photon hitting this pixel.
 * @throws org.apache.commons.math.MathException
 */
@Override
public double generatePixelSignature(int pixelX, int pixelY)
        throws MathException {
    final double sigma_0 = this.FWHM / 2.3548;
    final double zR = 2 * sigma_0 / this.numericalAperture; // Rayleigh range
    
    // Add the offset from the stage's position to the emitter's z-values
    double z;
    z = this.eZ + this.stageDisplacement;
    
    double sigma = sigma_0 * sqrt(1 + (z/ zR) * (z / zR));
    double denom = sqrt(2.0)*sigma;
    return 0.25 *(Erf.erf((pixelX - this.eX + 0.5)/denom) - 
                  Erf.erf((pixelX - this.eX - 0.5)/denom)) *
                 (Erf.erf((pixelY - this.eY + 0.5)/denom) -
                  Erf.erf((pixelY - this.eY - 0.5)/denom));
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
    * For this distribution, X, this method returns P(X &lt; <code>x</code>).
    *
    * @param x the value at which the CDF is evaluated.
    * @return CDF evaluted at <code>x</code>.
    * @throws MathException if the algorithm fails to converge; unless
    *                       x is more than 20 standard deviations from the mean, in which case the
    *                       convergence exception is caught and 0 or 1 is returned.
    */
   @Override
public double cumulativeProbability(double x) throws MathException {
       try {
           return 0.5 * (1.0 + Erf.erf((x - mean) /
                   (standardDeviation * Math.sqrt(2.0))));
       } catch (MaxIterationsExceededException ex) {
           if (x < (mean - 20 * standardDeviation)) { // JDK 1.5 blows at 38
               return 0.0d;
           } else if (x > (mean + 20 * standardDeviation)) {
               return 1.0d;
           } else {
               throw ex;
           }
       }
   }
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this distribution, X, this method returns P(X &lt; <code>x</code>).
 * @param x the value at which the CDF is evaluated.
 * @return CDF evaluted at <code>x</code>. 
 * @throws MathException if the algorithm fails to converge; unless
 * x is more than 20 standard deviations from the mean, in which case the
 * convergence exception is caught and 0 or 1 is returned.
 */
public double cumulativeProbability(double x) throws MathException {
    try {
        return 0.5 * (1.0 + Erf.erf((x - mean) /
                (standardDeviation * Math.sqrt(2.0))));
    } catch (MaxIterationsExceededException ex) {
        if (x < (mean - 20 * standardDeviation)) { // JDK 1.5 blows at 38
            return 0.0d;
        } else if (x > (mean + 20 * standardDeviation)) {
            return 1.0d;
        } else {
            throw ex;
        }
    }
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * Computes the relative probability of receiving a photon at the pixel.
 * (emitterX, emitterY). The z-position of the emitter is ignored.
 * @param pixelX The pixel's x-position.
 * @param pixelY The pixel's y-position.

 * @return The probability of a photon hitting this pixel.
 * @throws org.apache.commons.math.MathException
 */
@Override
public double generatePixelSignature(int pixelX, int pixelY)
        throws MathException {
    final double sigma = this.FWHM / 2.3548;
    final double denom = sqrt(2.0)*sigma;
    return 0.25 *(Erf.erf((pixelX - this.eX + 0.5)/denom) - 
                  Erf.erf((pixelX - this.eX - 0.5)/denom)) *
                 (Erf.erf((pixelY - this.eY + 0.5)/denom) -
                  Erf.erf((pixelY - this.eY - 0.5)/denom));
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * This function should implement the new PSF shape for the 3D fluorophore
 * @param x x-position of camera pixel
 * @param y y-position of camera pixel
 * @param camera_fwhm_digital fwhm of gaussian PSF
 * @return normalized value of pixel brightness (ie how bright is this particular
 * pixel due to emission from the relevant fluorophore)
 * @throws MathException 
 */
@Override
protected double generate_signature_for_pixel(int x, int y, double camera_fwhm_digital) throws MathException {
    final double sigma = camera_fwhm_digital / 2.3548;
    final double denom = sqrt(2.0)*sigma;
    
    // this is just an example of a z-dependent PSF, it is not the physically
    // accurate normalized PSF, I just made one up so it could be demonstrated
    double z_factor = Math.exp(z);
    
    return 0.25 *(Erf.erf(z_factor*(x-this.x+0.5)/denom) - Erf.erf(z_factor*(x-this.x-0.5)/denom)) *
                 (Erf.erf((y-this.y+0.5)/denom/z_factor) - Erf.erf((y-this.y-0.5)/denom/z_factor));
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this disbution, X, this method returns P(X &lt; <code>x</code>).
 * @param x the value at which the CDF is evaluated.
 * @return CDF evaluted at <code>x</code>. 
 * @throws MathException if the algorithm fails to converge; unless
 * x is more than 20 standard deviations from the mean, in which case the
 * convergence exception is caught and 0 or 1 is returned.
 */
public double cumulativeProbability(double x) throws MathException {
    try {
        return 0.5 * (1.0 + Erf.erf((x - mean) /
                (standardDeviation * Math.sqrt(2.0))));
    } catch (MaxIterationsExceededException ex) {
        if (x < (mean - 20 * standardDeviation)) { // JDK 1.5 blows at 38
            return 0.0d;
        } else if (x > (mean + 20 * standardDeviation)) {
            return 1.0d;
        } else {
            throw ex;
        }
    }
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this distribution, X, this method returns P(X &lt; <code>x</code>).
 * @param x the value at which the CDF is evaluated.
 * @return CDF evaluted at <code>x</code>.
 * @throws MathException if the algorithm fails to converge; unless
 * x is more than 20 standard deviations from the mean, in which case the
 * convergence exception is caught and 0 or 1 is returned.
 */
public double cumulativeProbability(double x) throws MathException {
    try {
        return 0.5 * (1.0 + Erf.erf((x - mean) /
                (standardDeviation * Math.sqrt(2.0))));
    } catch (MaxIterationsExceededException ex) {
        if (x < (mean - 20 * standardDeviation)) { // JDK 1.5 blows at 38
            return 0.0d;
        } else if (x > (mean + 20 * standardDeviation)) {
            return 1.0d;
        } else {
            throw ex;
        }
    }
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * Return the value of the error function calculated using the Apache Commons Math.
 * @param x Where to evaluate the error function at.
 * @return the value of the error function evaluated at x.
 */
public static double erf(double x)
{
		try
		{
			double value = Erf.erf(x);
			return value;
		}
		catch (MathException e)
		{
			throw new afest.math.exceptions.MathException("Algorithm failed to converge! "+e.getMessage());
		}
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this distribution, X, this method returns P(X &lt; <code>x</code>).
 *
 * @param x the value at which the CDF is evaluated.
 * @return CDF evaluted at <code>x</code>.
 * @throws MathException if the algorithm fails to converge; unless
 *                       x is more than 20 standard deviations from the mean, in which case the
 *                       convergence exception is caught and 0 or 1 is returned.
 */
public double cumulativeProbability(double x) throws MathException {
    try {
        return 0.5 * (1.0 + Erf.erf((x - mean) /
                (standardDeviation * Math.sqrt(2.0))));
    } catch (MaxIterationsExceededException ex) {
        if (x < (mean - 20 * standardDeviation)) { // JDK 1.5 blows at 38
            return 0.0d;
        } else if (x > (mean + 20 * standardDeviation)) {
            return 1.0d;
        } else {
            throw ex;
        }
    }
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * Returns the signature that this emitter leaves on a given pixel (what
 * fraction of this emitter's photons hits this particular pixel).
 * @param x pixel x-position
 * @param y pixel y-position
 * @param camera_fwhm_digital camera fwhm value
 * @return signature value for this pixel
 * @throws MathException
 * @deprecated This behavior has been moved to the PSF interface
 */
@Deprecated
protected double generate_signature_for_pixel(int x, int y, double camera_fwhm_digital) throws MathException {
    final double sigma = camera_fwhm_digital / 2.3548;
    final double denom = sqrt(2.0)*sigma;
    return 0.25 *(Erf.erf((x-this.x+0.5)/denom) - Erf.erf((x-this.x-0.5)/denom)) *
                 (Erf.erf((y-this.y+0.5)/denom) - Erf.erf((y-this.y-0.5)/denom));
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this distribution, {@code X}, this method returns {@code P(X < x)}.
 * If {@code x}is more than 40 standard deviations from the mean, 0 or 1 is returned,
 * as in these cases the actual value is within {@code Double.MIN_VALUE} of 0 or 1.
 *
 * @param x Value at which the CDF is evaluated.
 * @return CDF evaluated at {@code x}.
 * @throws MathException if the algorithm fails to converge
 */
public double cumulativeProbability(double x) throws MathException {
    final double dev = x - mean;
    if (FastMath.abs(dev) > 40 * standardDeviation) {
        return dev < 0 ? 0.0d : 1.0d;
    }
    return 0.5 * (1 + Erf.erf(dev / (standardDeviation * FastMath.sqrt(2))));
}
 

import org.apache.commons.math.special.Erf; //导入依赖的package包/类
/**
 * For this disbution, X, this method returns P(X &lt; <code>x</code>).
 * @param x the value at which the CDF is evaluated.
 * @return CDF evaluted at <code>x</code>. 
 * @throws MathException if the algorithm fails to converge.
 */
public double cumulativeProbability(double x) throws MathException {
    return 0.5 * (1.0 + Erf.erf((x - mean) /
            (standardDeviation * Math.sqrt(2.0))));
}