Examples with SeededTest uk.ac.sussex.gdsc.test.junit5.SeededTest used on opensource projects

Example 11 with SeededTest

use of uk.ac.sussex.gdsc.test.junit5.SeededTest in project GDSC-SMLM by aherbert.

the class LvmGradientProcedureTest method gradientProcedureFastLogMleCannotComputeGradientWithHighPrecision.

@Disabled("This test now passes as the tolerance for computing the gradient has been lowered " + " so that the tests pass under a stress test using many different random seeds.")
@SeededTest
void gradientProcedureFastLogMleCannotComputeGradientWithHighPrecision(RandomSeed seed) {
    // Try different precision
    for (int n = FastLog.N; n < 23; n++) {
        try {
            // logger.fine(FunctionUtils.getSupplier("Precision n=%d", n);
            fastLog = new TurboLog2(n);
            gradientProcedureComputesGradient(seed, new SingleFreeCircularErfGaussian2DFunction(blockWidth, blockWidth), Type.FAST_LOG_MLE, false);
        } catch (final AssertionError ex) {
            continue;
        } finally {
            // Reset
            fastLog = null;
        }
        return;
    }
    Assertions.fail();
}

Example 12 with SeededTest

use of uk.ac.sussex.gdsc.test.junit5.SeededTest in project GDSC-SMLM by aherbert.

the class BinomialFitterTest method canFitZeroTruncatedBinomialWithUnknownNUsingMaximumLikelihood.

@SeededTest
void canFitZeroTruncatedBinomialWithUnknownNUsingMaximumLikelihood(RandomSeed seed) {
    Assumptions.assumeTrue(TestSettings.allow(nonEssentialTestComplexity));
    final UniformRandomProvider rg = RngUtils.create(seed.getSeed());
    final boolean zeroTruncated = true;
    final boolean maximumLikelihood = false;
    for (final int n : N) {
        for (final double p : P) {
            fitBinomial(rg, n, p, zeroTruncated, maximumLikelihood, 1, n);
        }
    }
}

Example 13 with SeededTest

use of uk.ac.sussex.gdsc.test.junit5.SeededTest in project GDSC-SMLM by aherbert.

the class BinomialFitterTest method canFitBinomialWithUnknownNUsingLeastSquaresEstimator.

@SeededTest
void canFitBinomialWithUnknownNUsingLeastSquaresEstimator(RandomSeed seed) {
    Assumptions.assumeTrue(TestSettings.allow(nonEssentialTestComplexity));
    final UniformRandomProvider rg = RngUtils.create(seed.getSeed());
    final boolean zeroTruncated = false;
    final boolean maximumLikelihood = false;
    for (final int n : N) {
        for (final double p : P) {
            fitBinomial(rg, n, p, zeroTruncated, maximumLikelihood, 1, n);
        }
    }
}

Example 14 with SeededTest

use of uk.ac.sussex.gdsc.test.junit5.SeededTest in project GDSC-SMLM by aherbert.

the class JumpDistanceAnalysisTest method canDoBenchmark.

/**
 * This is not actually a test but runs the fitting algorithm many times to collect benchmark data
 * to file.
 */
@SeededTest
void canDoBenchmark(RandomSeed seed) {
    // Skip this as it is slow
    Assumptions.assumeTrue(false);
    final UniformRandomProvider rg = RngUtils.create(seed.getSeed());
    out = null;
    try {
        final FileOutputStream fos = new FileOutputStream("JumpDistanceAnalysisTest.dat");
        out = new OutputStreamWriter(fos, "UTF-8");
        // Run the fitting to produce benchmark data for a mixed population of 2
        final int n = 2;
        writeHeader(n);
        for (int repeat = 10; repeat-- > 0; ) {
            resetData();
            for (final boolean mle : new boolean[] { true, false }) {
                for (int f = 1; f <= 9; f++) {
                    final double fraction = f / 10.0;
                    final String title = String.format("%s Dual=%.1f", (mle) ? "MLE" : "LSQ", fraction);
                    for (int samples = 500, k = 0; k < 6; samples *= 2, k++) {
                        for (int i = 0; i < D.length; i++) {
                            for (int j = i + 1; j < D.length; j++) {
                                try {
                                    fit(rg, title, samples, 0, new double[] { D[i], D[j] }, new double[] { fraction, 1 - fraction }, mle);
                                } catch (final AssertionError ex) {
                                // Carry on with the benchmarking
                                }
                                // If the fit had the correct N then no need to repeat
                                if (fitN == n) {
                                    continue;
                                }
                                try {
                                    fit(rg, title + " Fixed", samples, n, new double[] { D[i], D[j] }, new double[] { fraction, 1 - fraction }, mle);
                                } catch (final AssertionError ex) {
                                // Carry on with the benchmarking
                                }
                            }
                        }
                    }
                }
            }
        }
    } catch (final Exception ex) {
        throw new AssertionError("Failed to complete benchmark", ex);
    } finally {
        closeOutput();
    }
}

Example 15 with SeededTest

use of uk.ac.sussex.gdsc.test.junit5.SeededTest in project GDSC-SMLM by aherbert.

the class SolverSpeedTest method solveLinearAndGaussJordanReturnSameSolutionAndInversionResult.

@SeededTest
void solveLinearAndGaussJordanReturnSameSolutionAndInversionResult(RandomSeed seed) {
    final int iter = 100;
    final SolverSpeedTestData data = ensureData(seed, iter);
    final ArrayList<double[][]> adata = copyAdouble(data.adata, iter);
    final ArrayList<double[]> bdata = copyBdouble(data.bdata, iter);
    final ArrayList<double[][]> adata2 = copyAdouble(data.adata, iter);
    final ArrayList<double[]> bdata2 = copyBdouble(data.bdata, iter);
    final GaussJordan solver = new GaussJordan();
    final EjmlLinearSolver solver2 = new EjmlLinearSolver();
    final int failureLimit = TestCounter.computeFailureLimit(iter, 0.1);
    final TestCounter failCounter = new TestCounter(failureLimit, 2);
    final DoubleDoubleBiPredicate predicate = TestHelper.doublesAreClose(1e-2, 0);
    int fail = 0;
    for (int i = 0; i < adata.size(); i++) {
        final double[][] a1 = adata.get(i);
        final double[] b1 = bdata.get(i);
        final double[][] a2 = adata2.get(i);
        final double[] b2 = bdata2.get(i);
        final boolean r1 = solver.solve(a1, b1);
        final boolean r2 = solver2.solveLinear(a2, b2);
        solver2.invertLastA(a2);
        // Assertions.assertTrue("Different solve result @ " + i, r1 == r2);
        if (r1 && r2) {
            failCounter.run(0, () -> {
                TestAssertions.assertArrayTest(b1, b2, predicate, "Different b result");
            });
            failCounter.run(0, () -> {
                TestAssertions.assertArrayTest(a1, a2, predicate, "Different a result");
            });
        } else {
            fail++;
        }
    }
    if (fail > iter / 2) {
        Assertions.fail(String.format("Failed to solve %d / %d", fail, iter));
    }
}