Examples with BenchmarkMatrix jmbench.interfaces.BenchmarkMatrix used on opensource projects

Example 1 with BenchmarkMatrix

use of jmbench.interfaces.BenchmarkMatrix in project Java-Matrix-Benchmark by lessthanoptimal.

the class SolveOverGenerator method createInputs.

@Override
public BenchmarkMatrix[] createInputs(MatrixFactory factory, Random rand, int size) {
    BenchmarkMatrix[] inputs = new BenchmarkMatrix[2];
    // A
    inputs[0] = factory.create(3 * size, size);
    // B
    inputs[1] = factory.create(3 * size, 1);
    randomize(inputs[0], -1, 1, rand);
    // make sure an exact solution exists
    RowMajorMatrix A = new RowMajorMatrix(inputs[0]);
    RowMajorMatrix B = new RowMajorMatrix(3 * size, 1);
    RowMajorMatrix X = RowMajorOps.createRandom(size, 1, -1, 1, rand);
    RowMajorOps.mult(A, X, B);
    convertToBm(B, inputs[1]);
    return inputs;
}

Example 2 with BenchmarkMatrix

use of jmbench.interfaces.BenchmarkMatrix in project Java-Matrix-Benchmark by lessthanoptimal.

the class MemoryTest method evaluate.

@Override
public TestResults evaluate() {
    Random rand = new Random(randomSeed);
    BenchmarkMatrix[] inputs = gen != null ? gen.createInputs(factory, rand, size) : null;
    double[] mod = null;
    if (gen != null) {
        mod = new double[inputs.length];
        for (int i = 0; i < inputs.length; i++) {
            mod[i] = inputs[i].get(0, 0);
        }
    }
    MatrixProcessorInterface operation = createAlgorithm();
    // see if the operation is supported
    if (operation == null) {
        return new Results(-1);
    }
    long start = System.currentTimeMillis();
    // output is null since that might require creating new memory, which isn't strictly part of th test
    operation.process(inputs, null, N);
    long stop = System.currentTimeMillis();
    if (gen != null) {
        for (int i = 0; i < inputs.length; i++) {
            if (mod[i] != inputs[i].get(0, 0))
                throw new RuntimeException("Input modified! Input " + i);
        }
    }
    // the application exits
    synchronized (this) {
        try {
            wait(300);
        } catch (InterruptedException e) {
        }
    }
    return new Results(stop - start);
}

Example 3 with BenchmarkMatrix

use of jmbench.interfaces.BenchmarkMatrix in project Java-Matrix-Benchmark by lessthanoptimal.

the class SolverAccuracy method evaluateSolver.

private void evaluateSolver() {
    reason = OutputError.NO_ERROR;
    foundResult = Double.NaN;
    BenchmarkMatrix[] inputsB = new BenchmarkMatrix[2];
    BenchmarkMatrix[] outputB = new BenchmarkMatrix[1];
    inputsB[0] = factory.convertToLib(A);
    inputsB[1] = factory.convertToLib(b);
    MatrixProcessorInterface operation = createAlgorithm();
    if (operation == null) {
        reason = OutputError.NOT_SUPPORTED;
        return;
    }
    try {
        operation.process(inputsB, outputB, 1);
    } catch (DetectedException e) {
        reason = OutputError.DETECTED_FAILURE;
        return;
    } catch (Exception e) {
        addUnexpectedException(e);
        reason = OutputError.UNEXPECTED_EXCEPTION;
        return;
    }
    RowMajorMatrix[] results = new RowMajorMatrix[outputB.length];
    for (int i = 0; i < results.length; i++) results[i] = factory.convertToRowMajor(outputB[i]);
    RowMajorMatrix x = results[0];
    if (RowMajorOps.hasUncountable(x)) {
        reason = OutputError.UNCOUNTABLE;
        return;
    }
    foundResult = StabilityBenchmark.residualErrorMetric(A, x, b);
    if (Double.isNaN(foundResult) || Double.isInfinite(foundResult)) {
        reason = OutputError.LARGE_ERROR;
        return;
    }
}

Example 4 with BenchmarkMatrix

use of jmbench.interfaces.BenchmarkMatrix in project Java-Matrix-Benchmark by lessthanoptimal.

the class SolverOverflow method check.

@Override
public boolean check(int testPoint) {
    // System.out.println("check = "+testPoint);
    double scale = Math.pow(scaling, testPoint);
    RowMajorOps.scale(scale, A, A_scale);
    RowMajorOps.scale(scale, b, b_scale);
    BenchmarkMatrix[] inputsB = new BenchmarkMatrix[2];
    BenchmarkMatrix[] outputB = new BenchmarkMatrix[1];
    inputsB[0] = factory.convertToLib(A_scale);
    inputsB[1] = factory.convertToLib(b_scale);
    MatrixProcessorInterface operation = createAlgorithm();
    if (operation == null) {
        reason = OutputError.NOT_SUPPORTED;
        return false;
    }
    try {
        operation.process(inputsB, outputB, 1);
    } catch (DetectedException e) {
        reason = OutputError.DETECTED_FAILURE;
        return false;
    } catch (Exception e) {
        addUnexpectedException(e);
        reason = OutputError.UNEXPECTED_EXCEPTION;
        return false;
    }
    RowMajorMatrix[] results = new RowMajorMatrix[outputB.length];
    for (int i = 0; i < results.length; i++) results[i] = factory.convertToRowMajor(outputB[i]);
    RowMajorMatrix x = results[0];
    if (RowMajorOps.hasUncountable(x)) {
        reason = OutputError.UNCOUNTABLE;
        return false;
    }
    double error = StabilityBenchmark.residualErrorMetric(A_scale, x, b_scale);
    // was countable, it only become uncountable when computing the error.
    if (Double.isNaN(error) || Double.isInfinite(error) || error > breakingPoint) {
        reason = OutputError.LARGE_ERROR;
        return false;
    }
    System.gc();
    Thread.yield();
    return true;
}

Example 5 with BenchmarkMatrix

use of jmbench.interfaces.BenchmarkMatrix in project Java-Matrix-Benchmark by lessthanoptimal.

the class OverflowTestBase method check.

@Override
public boolean check(int testPoint) {
    double scale = Math.pow(scaling, testPoint);
    Ascaled.set(A);
    RowMajorOps.scale(scale, Ascaled);
    RowMajorMatrix[] inputs = new RowMajorMatrix[] { Ascaled };
    BenchmarkMatrix[] inputsB = new BenchmarkMatrix[inputs.length];
    BenchmarkMatrix[] outputB = new BenchmarkMatrix[getNumOutputs()];
    for (int i = 0; i < inputs.length; i++) {
        inputsB[i] = factory.convertToLib(inputs[i]);
    }
    MatrixProcessorInterface operation = createAlgorithm();
    if (operation == null) {
        reason = OutputError.NOT_SUPPORTED;
        return false;
    }
    try {
        operation.process(inputsB, outputB, 1);
    } catch (DetectedException e) {
        reason = OutputError.DETECTED_FAILURE;
        return false;
    } catch (Exception e) {
        addUnexpectedException(e);
        reason = OutputError.UNEXPECTED_EXCEPTION;
        return false;
    }
    RowMajorMatrix[] results = new RowMajorMatrix[outputB.length];
    for (int i = 0; i < results.length; i++) results[i] = factory.convertToRowMajor(outputB[i]);
    for (RowMajorMatrix R : results) {
        if (RowMajorOps.hasUncountable(R)) {
            reason = OutputError.UNCOUNTABLE;
            return false;
        }
    }
    return checkResults(results);
}