Java Beta.regularizedBeta方法代码示例

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包/类
/**
 * {@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} */
public double cumulativeProbability(int x) {
    double ret;
    if (x < 0) {
        ret = 0.0;
    } else {
        ret = Beta.regularizedBeta(probabilityOfSuccess,
                numberOfSuccesses, x + 1);
    }
    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入方法依赖的package包/类
/**
 * Evaluates the function.
 * 
 * @param x  x
 * @return the value of the function
 * @throws IllegalArgumentException if $x < 0$ or $x > 1$
 */
@Override
public Double apply(Double x) {
  ArgChecker.isTrue(x >= 0 && x <= 1, "x must be in the range 0 to 1");
  try {
    return Beta.regularizedBeta(x, _a, _b, _eps, _maxIter);
  } catch (MaxCountExceededException e) {
    throw new MathException(e);
  }
}
 

import org.apache.commons.math3.special.Beta; //导入方法依赖的package包/类
@Override
public double cumulativeProbability(double x) {

    double ret;
    if (x < 0) {
        ret = 0.0D;
    } else if (x >= this.numberOfTrials) {
        ret = 1.0D;
    } else {
        ret = 1.0D - Beta.regularizedBeta(this.probabilityOfSuccess, x + 1.0D, (this.numberOfTrials - x));
    }

    return ret;
}
 

import org.apache.commons.math3.special.Beta; //导入方法依赖的package包/类
private static double calculateHomozygousLogRatio(final AllelicCount allelicCount,
                                                  final double genotypingBaseErrorRate) {
    final int r = allelicCount.getRefReadCount();
    final int n = allelicCount.getTotalReadCount();
    final double betaAll = Beta.regularizedBeta(1, r + 1, n - r + 1);
    final double betaError = Beta.regularizedBeta(genotypingBaseErrorRate, r + 1, n - r + 1);
    final double betaOneMinusError = Beta.regularizedBeta(1 - genotypingBaseErrorRate, r + 1, n - r + 1);
    final double betaHom = betaError + betaAll - betaOneMinusError;
    final double betaHet = betaOneMinusError - betaError;
    return FastMath.log(betaHom) - FastMath.log(betaHet);
}
 

import org.apache.commons.math3.special.Beta; //导入方法依赖的package包/类
public double cdf(double x) {
    double r = -1 * (mean*mean) / (mean - stdev*stdev);
    double p = mean / (stdev*stdev);
    return Beta.regularizedBeta(p, r, x + 1);
}