import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} */
public double cumulativeProbability(double x) {
    double ret;
    if (x == 0) {
        ret = 0.5;
    } else {
        double t =
            Beta.regularizedBeta(
                degreesOfFreedom / (degreesOfFreedom + (x * x)),
                0.5 * degreesOfFreedom,
                0.5);
        if (x < 0.0) {
            ret = 0.5 * t;
        } else {
            ret = 1.0 - 0.5 * t;
        }
    }

    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/**
 *  Initialize minor fractions assuming no allelic bias <p></p>
 *
 * We integrate over f to get posterior probabilities (responsibilities) of alt / ref minor
 * that is, responsibility of alt minor is int_{0 to 1/2} f^a (1-f)^r df
 *          responsibility of ref minor is int_{0 to 1/2} f^r (1-f)^a df
 * these are proportional to I(1/2, a + 1, r + 1) and I(1/2, r + 1, a + 1),
 * respectively, where I is the (incomplete) regularized Beta function.
 * By definition these likelihoods sum to 1, ie they are already normalized. <p></p>
 *
 * Finally, we set each minor fraction to the responsibility-weighted total count of
 * reads in minor allele divided by total reads, ignoring outliers.
 */
private AlleleFractionState.MinorFractions initialMinorFractions(final AlleleFractionData data) {
    final int numSegments = data.getNumSegments();
    final AlleleFractionState.MinorFractions result = new AlleleFractionState.MinorFractions(numSegments);
    for (int segment = 0; segment < numSegments; segment++) {
        double responsibilityWeightedMinorAlleleReadCount = 0.0;
        double responsibilityWeightedTotalReadCount = 0.0;
        for (final AllelicCount count : data.getCountsInSegment(segment)) {
            final int a = count.getAltReadCount();
            final int r = count.getRefReadCount();
            double altMinorResponsibility;
            try {
                altMinorResponsibility = Beta.regularizedBeta(0.5, a + 1, r + 1);
            } catch (final MaxCountExceededException e) {
                altMinorResponsibility = a < r ? 1.0 : 0.0; //if the special function can't be computed, give an all-or-nothing responsibility
            }
            responsibilityWeightedMinorAlleleReadCount += altMinorResponsibility * a + (1 - altMinorResponsibility) * r;
            responsibilityWeightedTotalReadCount += a + r;
        }

        // we achieve a flat prior via a single pseudocount for minor and non-minor reads, hence the  +1 and +2
        result.add((responsibilityWeightedMinorAlleleReadCount + 1)/(responsibilityWeightedTotalReadCount + 2));
    }
    return result;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/**
 * <p>
 *     Initialize minor fractions assuming no allelic bias.
 * </p>
 *
 * <p>
 *     We integrate over f to get posterior probabilities (responsibilities) of alt / ref minor
 *     that is, responsibility of alt minor is int_{0 to 1/2} f^a (1 - f)^r df
 *              responsibility of ref minor is int_{0 to 1/2} f^r (1 - f)^a df
 *     These are proportional to I(1/2, a + 1, r + 1) and I(1/2, r + 1, a + 1),
 *     respectively, where I is the (incomplete) regularized Beta function.
 *     By definition, these likelihoods sum to 1, i.e., they are already normalized.
 * </p>
 *
 * <p>
 *     Finally, we set each minor fraction to the responsibility-weighted total count of
 *     reads in minor allele divided by total reads, ignoring outliers.
 * </p>
 */
private AlleleFractionState.MinorFractions calculateInitialMinorFractions(final AlleleFractionSegmentedData data) {
    final int numSegments = data.getNumSegments();
    final AlleleFractionState.MinorFractions result = new AlleleFractionState.MinorFractions(numSegments);
    for (int segment = 0; segment < numSegments; segment++) {
        double responsibilityWeightedMinorAlleleReadCount = 0.0;
        double responsibilityWeightedTotalReadCount = 0.0;
        for (final AllelicCount count : data.getIndexedAllelicCountsInSegment(segment)) {
            final int a = count.getAltReadCount();
            final int r = count.getRefReadCount();
            double altMinorResponsibility;
            try {
                altMinorResponsibility = Beta.regularizedBeta(0.5, a + 1, r + 1);
            } catch (final MaxCountExceededException e) {
                altMinorResponsibility = a < r ? 1.0 : 0.0; //if the special function can't be computed, give an all-or-nothing responsibility
            }
            responsibilityWeightedMinorAlleleReadCount += altMinorResponsibility * a + (1 - altMinorResponsibility) * r;
            responsibilityWeightedTotalReadCount += a + r;
        }

        // we achieve a flat prior via a single pseudocount for minor and non-minor reads, hence the  +1 and +2
        result.add((responsibilityWeightedMinorAlleleReadCount + 1)/(responsibilityWeightedTotalReadCount + 2));
    }
    return result;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} **/
@Override
public double logDensity(double x) {
    final double nhalf = numeratorDegreesOfFreedom / 2;
    final double mhalf = denominatorDegreesOfFreedom / 2;
    final double logx = FastMath.log(x);
    final double logn = FastMath.log(numeratorDegreesOfFreedom);
    final double logm = FastMath.log(denominatorDegreesOfFreedom);
    final double lognxm = FastMath.log(numeratorDegreesOfFreedom * x +
            denominatorDegreesOfFreedom);
    return nhalf * logn + nhalf * logx - logx +
           mhalf * logm - nhalf * lognxm - mhalf * lognxm -
           Beta.logBeta(nhalf, mhalf);
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * The implementation of this method is based on
 * <ul>
 *  <li>
 *   <a href="http://mathworld.wolfram.com/F-Distribution.html">
 *   F-Distribution</a>, equation (4).
 *  </li>
 * </ul>
 */
public double cumulativeProbability(double x)  {
    double ret;
    if (x <= 0) {
        ret = 0;
    } else {
        double n = numeratorDegreesOfFreedom;
        double m = denominatorDegreesOfFreedom;

        ret = Beta.regularizedBeta((n * x) / (m + n * x),
            0.5 * n,
            0.5 * m);
    }
    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} */
public double cumulativeProbability(double x)  {
    if (x <= 0) {
        return 0;
    } else if (x >= 1) {
        return 1;
    } else {
        return Beta.regularizedBeta(x, alpha, beta);
    }
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} */
public double cumulativeProbability(int x) {
    double ret;
    if (x < 0) {
        ret = 0.0;
    } else if (x >= numberOfTrials) {
        ret = 1.0;
    } else {
        ret = 1.0 - Beta.regularizedBeta(probabilityOfSuccess,
                x + 1.0, numberOfTrials - x);
    }
    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} */
public double cumulativeProbability(int x) {
    double ret;
    if (x < 0) {
        ret = 0.0;
    } else {
        ret = Beta.regularizedBeta(probabilityOfSuccess,
                numberOfSuccesses, x + 1.0);
    }
    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @since 2.1
 */
public double density(double x) {
    final double nhalf = numeratorDegreesOfFreedom / 2;
    final double mhalf = denominatorDegreesOfFreedom / 2;
    final double logx = FastMath.log(x);
    final double logn = FastMath.log(numeratorDegreesOfFreedom);
    final double logm = FastMath.log(denominatorDegreesOfFreedom);
    final double lognxm = FastMath.log(numeratorDegreesOfFreedom * x +
                                       denominatorDegreesOfFreedom);
    return FastMath.exp(nhalf * logn + nhalf * logx - logx +
                        mhalf * logm - nhalf * lognxm - mhalf * lognxm -
                        Beta.logBeta(nhalf, mhalf));
}
 

import org.apache.commons.math3.special.Beta; //导入依赖的package包/类
/** {@inheritDoc} */
public double cumulativeProbability(int x) {
    double ret;
    if (x < 0) {
        ret = 0.0;
    } else {
        ret = Beta.regularizedBeta(probabilityOfSuccess,
                numberOfSuccesses, x + 1);
    }
    return ret;
}