Java FieldMatrix.getEntry方法代码示例

import org.apache.commons.math3.linear.FieldMatrix; //导入方法依赖的package包/类
/**
 * Calculates the exact value of {@code P(D_n < d)} using method described
 * in [1] and {@link org.apache.commons.math3.fraction.BigFraction} (see
 * above).
 *
 * @param d statistic
 * @return the two-sided probability of {@code P(D_n < d)}
 * @throws MathArithmeticException if algorithm fails to convert {@code h}
 * to a {@link org.apache.commons.math3.fraction.BigFraction} in expressing
 * {@code d} as {@code (k - h) / m} for integer {@code k, m} and
 * {@code 0 <= h < 1}.
 */
private double exactK(double d) throws MathArithmeticException {

    final int k = (int) FastMath.ceil(n * d);

    final FieldMatrix<BigFraction> H = this.createH(d);
    final FieldMatrix<BigFraction> Hpower = H.power(n);

    BigFraction pFrac = Hpower.getEntry(k - 1, k - 1);

    for (int i = 1; i <= n; ++i) {
        pFrac = pFrac.multiply(i).divide(n);
    }

    /*
     * BigFraction.doubleValue converts numerator to double and the
     * denominator to double and divides afterwards. That gives NaN quite
     * easy. This does not (scale is the number of digits):
     */
    return pFrac.bigDecimalValue(20, BigDecimal.ROUND_HALF_UP).doubleValue();
}
 

import org.apache.commons.math3.linear.FieldMatrix; //导入方法依赖的package包/类
/**
 * Calculates the exact value of {@code P(D_n < d)} using the method described in [1] (reference
 * in class javadoc above) and {@link org.apache.commons.math3.fraction.BigFraction} (see
 * above).
 *
 * @param d statistic
 * @param n sample size
 * @return the two-sided probability of \(P(D_n < d)\)
 * @throws MathArithmeticException if algorithm fails to convert {@code h} to a
 *         {@link org.apache.commons.math3.fraction.BigFraction} in expressing {@code d} as \((k
 *         - h) / m\) for integer {@code k, m} and \(0 \le h < 1\).
 */
private double exactK(double d, int n)
    throws MathArithmeticException {

    final int k = (int) Math.ceil(n * d);

    final FieldMatrix<BigFraction> H = this.createExactH(d, n);
    final FieldMatrix<BigFraction> Hpower = H.power(n);

    BigFraction pFrac = Hpower.getEntry(k - 1, k - 1);

    for (int i = 1; i <= n; ++i) {
        pFrac = pFrac.multiply(i).divide(n);
    }

    /*
     * BigFraction.doubleValue converts numerator to double and the denominator to double and
     * divides afterwards. That gives NaN quite easy. This does not (scale is the number of
     * digits):
     */
    return pFrac.bigDecimalValue(20, BigDecimal.ROUND_HALF_UP).doubleValue();
}
 

import org.apache.commons.math3.linear.FieldMatrix; //导入方法依赖的package包/类
/** verifies that two matrices are equal */
public static void assertEquals(FieldMatrix<? extends FieldElement<?>> expected,
                                FieldMatrix<? extends FieldElement<?>> observed) {

    Assert.assertNotNull("Observed should not be null",observed);

    if (expected.getColumnDimension() != observed.getColumnDimension() ||
            expected.getRowDimension() != observed.getRowDimension()) {
        StringBuilder messageBuffer = new StringBuilder();
        messageBuffer.append("Observed has incorrect dimensions.");
        messageBuffer.append("\nobserved is " + observed.getRowDimension() +
                " x " + observed.getColumnDimension());
        messageBuffer.append("\nexpected " + expected.getRowDimension() +
                " x " + expected.getColumnDimension());
        Assert.fail(messageBuffer.toString());
    }

    for (int i = 0; i < expected.getRowDimension(); ++i) {
        for (int j = 0; j < expected.getColumnDimension(); ++j) {
            FieldElement<?> eij = expected.getEntry(i, j);
            FieldElement<?> oij = observed.getEntry(i, j);
            Assert.assertEquals(eij, oij);
        }
    }
}
 

import org.apache.commons.math3.linear.FieldMatrix; //导入方法依赖的package包/类
/**
 * Calculates the exact value of {@code P(D_n < d)} using method described
 * in [1] and {@link org.apache.commons.math3.fraction.BigFraction} (see
 * above).
 *
 * @param d statistic
 * @return the two-sided probability of {@code P(D_n < d)}
 * @throws MathArithmeticException if algorithm fails to convert {@code h}
 * to a {@link org.apache.commons.math3.fraction.BigFraction} in expressing
 * {@code d} as {@code (k - h) / m} for integer {@code k, m} and
 * {@code 0 <= h < 1}.
 */
private double exactK(double d) throws MathArithmeticException {

    final int k = (int) Math.ceil(n * d);

    final FieldMatrix<BigFraction> H = this.createH(d);
    final FieldMatrix<BigFraction> Hpower = H.power(n);

    BigFraction pFrac = Hpower.getEntry(k - 1, k - 1);

    for (int i = 1; i <= n; ++i) {
        pFrac = pFrac.multiply(i).divide(n);
    }

    /*
     * BigFraction.doubleValue converts numerator to double and the
     * denominator to double and divides afterwards. That gives NaN quite
     * easy. This does not (scale is the number of digits):
     */
    return pFrac.bigDecimalValue(20, BigDecimal.ROUND_HALF_UP).doubleValue();
}
 

import org.apache.commons.math3.linear.FieldMatrix; //导入方法依赖的package包/类
public static void out(FieldMatrix<Complex> field){
    for(int row = 0; row < field.getRowDimension(); row++){
        for(int column = 0; column < field.getColumnDimension(); column++){
            Complex c =field.getEntry(row, column);
            System.out.print(c.getReal()+ "(" + c.getImaginary() + "i)" + ", ");
        }
        System.out.println();
    }
}