private static QuadraticProgram createRandomQuadraticProgram(Random random, int objectiveSize, int solutionSize, int constraintSize) { DenseMatrix64F a = RandomMatrices.createRandom(objectiveSize, solutionSize, random); DenseMatrix64F b = RandomMatrices.createRandom(objectiveSize, 1, random); DenseMatrix64F c = RandomMatrices.createRandom(constraintSize, solutionSize, random); DenseMatrix64F d = RandomMatrices.createRandom(constraintSize, 1, random); return new QuadraticProgram(a, b, c, d); } }
public static void main(String[] args) { DenseMatrix64F m = RandomMatrices.createRandom(5,5,0,1,new Random(234)); List<String> labels = new ArrayList<>(); for (int i = 0; i < m.numRows; i++) { labels.add("Label "+i); } ConfusionMatrixPanel confusion = new ConfusionMatrixPanel(m,labels,300,false); confusion.setHighlightCategory(2); ShowImages.showWindow(confusion,"Window",true); }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void errorSVD() { SingularValueDecomposition<DenseMatrix64F> dec = DecompositionFactory.svd(16, 16, true, true, true); DenseMatrix64F m = RandomMatrices.createRandom(16, 16, new Random(64)); MatrixIO.print(System.out, m,"%.10e"); dec.decompose(m); System.out.println("SVs="+Arrays.toString(dec.getSingularValues())); }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void zeroMatrixSVD(){ DenseMatrix64F []testMatrices = new DenseMatrix64F[]{ RandomMatrices.createRandom(2, 2, new Random()), new DenseMatrix64F(2,2), new DenseMatrix64F(new double[][]{{1,1},{0,0}}) }; for(int i=0;i<testMatrices.length;i++) { DenseMatrix64F testMatrix = testMatrices[i]; System.out.println("Matrix "+ i + testMatrix); SolvePseudoInverseSvd svdPseudoInverseSolver = new SolvePseudoInverseSvd(testMatrix.numRows, testMatrix.numCols); boolean setAResult=svdPseudoInverseSolver.setA(new DenseMatrix64F(testMatrix)); int rank=SingularOps.rank(svdPseudoInverseSolver.getDecomposer(), 1e-10); System.out.println("Singular Values: "+ Arrays.toString(svdPseudoInverseSolver.getDecomposer().getSingularValues())); System.out.println("setA="+setAResult + " rank="+ rank); System.out.println("----------------------------------------------------------------------------------------------------"); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 40000) public void testEasyMultAddInner() { Random random = new Random(124L); int iters = 1000; for (int i = 0; i < iters; i++) { int variables = 4; int taskSize = 3; double diagonalScalar = RandomNumbers.nextDouble(random, 100.0); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(taskSize, variables, -50.0, 50.0, random); DenseMatrix64F solution = RandomMatrices.createRandom(variables, variables, -50.0, 50.0, random); DenseMatrix64F expectedSolution = new DenseMatrix64F(solution); DenseMatrix64F tempJtW = new DenseMatrix64F(variables, taskSize); CommonOps.transpose(randomMatrix, tempJtW); CommonOps.multAdd(diagonalScalar, tempJtW, randomMatrix, expectedSolution); MatrixTools.multAddInner(diagonalScalar, randomMatrix, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, 1e-6); } }
@ContinuousIntegrationTest(estimatedDuration = 0.5) @Test(timeout = 40000) public void testRandomMultAddInner() { Random random = new Random(124L); int iters = 100; for (int i = 0; i < iters; i++) { int variables = RandomNumbers.nextInt(random, 1, 100); int taskSize = RandomNumbers.nextInt(random, 1, 100); double scale = RandomNumbers.nextDouble(random, 100.0); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(taskSize, variables, -50.0, 50.0, random); DenseMatrix64F solution = RandomMatrices.createRandom(variables, variables, -50, 50, random); DenseMatrix64F expectedSolution = new DenseMatrix64F(solution); DenseMatrix64F tempJtW = new DenseMatrix64F(variables, taskSize); CommonOps.transpose(randomMatrix, tempJtW); CommonOps.multAdd(scale, tempJtW, randomMatrix, expectedSolution); MatrixTools.multAddInner(scale, randomMatrix, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, 1e-6); } } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 40000) public void testEasyInnerDiagonalMult() { Random random = new Random(124L); int iters = 1000; for (int i = 0; i < iters; i++) { int variables = 4; int taskSize = 3; int cols = 5; DenseMatrix64F diagonal = CommonOps.identity(taskSize, taskSize); DenseMatrix64F randomMatrixA = RandomMatrices.createRandom(variables, taskSize, -50.0, 50.0, random); DenseMatrix64F randomMatrixB = RandomMatrices.createRandom(taskSize, cols, -50.0, 50.0, random); DenseMatrix64F solution = new DenseMatrix64F(variables, cols); DenseMatrix64F expectedSolution = new DenseMatrix64F(variables, cols); for (int index = 0; index < taskSize; index++) { diagonal.set(index, index, RandomNumbers.nextDouble(random, 50.0)); } DenseMatrix64F temp = new DenseMatrix64F(taskSize, cols); CommonOps.mult(diagonal, randomMatrixB, temp); CommonOps.mult(randomMatrixA, temp, expectedSolution); DiagonalMatrixTools.innerDiagonalMult(randomMatrixA, diagonal, randomMatrixB, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 40000) public void testEasyInnerDiagonalMultTransA() { Random random = new Random(124L); int iters = 1000; for (int i = 0; i < iters; i++) { int variables = 4; int taskSize = 3; int cols = 5; DenseMatrix64F diagonal = CommonOps.identity(taskSize, taskSize); DenseMatrix64F randomMatrixA = RandomMatrices.createRandom(taskSize, variables, -50.0, 50.0, random); DenseMatrix64F randomMatrixB = RandomMatrices.createRandom(taskSize, cols, -50.0, 50.0, random); DenseMatrix64F solution = new DenseMatrix64F(variables, cols); DenseMatrix64F expectedSolution = new DenseMatrix64F(variables, cols); for (int index = 0; index < taskSize; index++) { diagonal.set(index, index, RandomNumbers.nextDouble(random, 50.0)); } DenseMatrix64F temp = new DenseMatrix64F(taskSize, cols); CommonOps.mult(diagonal, randomMatrixB, temp); CommonOps.multTransA(randomMatrixA, temp, expectedSolution); DiagonalMatrixTools.innerDiagonalMultTransA(randomMatrixA, diagonal, randomMatrixB, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testAgainstTaylorSeries() { int size = 50; Random random = new Random(125L); MatrixExponentialCalculator matrixExponentialCalculator = new MatrixExponentialCalculator(size); DenseMatrix64F A = RandomMatrices.createRandom(size, size, random); CommonOps.scale(1.0 / size, A); DenseMatrix64F result = new DenseMatrix64F(size, size); matrixExponentialCalculator.compute(result, A); DenseMatrix64F taylorSeriesCheck = new DenseMatrix64F(size, size); computeMatrixExponentialThroughTaylorSeries(taylorSeriesCheck, A, 15); assertTrue(MatrixFeatures.isIdentical(taylorSeriesCheck, result, 1e-6)); }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testRemoveNullspaceComponent2() { int matrixSize = 6; boolean makeLargestComponentPositive = true; SVDNullspaceCalculator nullspaceCalculator = new SVDNullspaceCalculator(matrixSize, makeLargestComponentPositive); Random random = new Random(); double[] singularValues = RandomNumbers.nextDoubleArray(random, matrixSize, 1.0, 2.0); singularValues[matrixSize / 2] = 0.0; DenseMatrix64F matrix1 = RandomMatrices.createSingularValues(matrixSize, matrixSize, random, singularValues); nullspaceCalculator.setMatrix(matrix1, 1); DenseMatrix64F nullspace = nullspaceCalculator.getNullspace(); DenseMatrix64F matrix2 = RandomMatrices.createRandom(matrixSize, matrixSize, random); nullspaceCalculator.removeNullspaceComponent(matrix2); assertTrue(isNullspaceComponentZero(matrix2, nullspace)); }
@ContinuousIntegrationTest(estimatedDuration = 0.1) @Test(timeout = 30000) public void testCompareDifferentImplementations() { int numberOfStates = 30; int numberOfInputs = 10; StateSpaceSystemDiscretizer singleMatrixExponentialDiscretizer = new SingleMatrixExponentialStateSpaceSystemDiscretizer(numberOfStates, numberOfInputs); StateSpaceSystemDiscretizer splitUpMatrixExponentialDiscretizer = new SplitUpMatrixExponentialStateSpaceSystemDiscretizer(numberOfStates, numberOfInputs); StateSpaceSystemDiscretizer[] discretizers = new StateSpaceSystemDiscretizer[] { singleMatrixExponentialDiscretizer, splitUpMatrixExponentialDiscretizer }; Random random = new Random(125L); DenseMatrix64F A = RandomMatrices.createRandom(numberOfStates, numberOfStates, random); DenseMatrix64F B = RandomMatrices.createRandom(numberOfStates, numberOfInputs, random); DenseMatrix64F Q = RandomMatrices.createSymmPosDef(numberOfStates, random); DenseMatrix64F[] As = new DenseMatrix64F[] { new DenseMatrix64F(A), new DenseMatrix64F(A) }; DenseMatrix64F[] Bs = new DenseMatrix64F[] { new DenseMatrix64F(B), new DenseMatrix64F(B) }; DenseMatrix64F[] Qs = new DenseMatrix64F[] { new DenseMatrix64F(Q), new DenseMatrix64F(Q) }; double dt = 1.0; for (int i = 0; i < discretizers.length; i++) { discretizers[i].discretize(As[i], Bs[i], Qs[i], dt); } double tol = 1e-12; EjmlUnitTests.assertEquals(As[0], As[1], tol); EjmlUnitTests.assertEquals(Bs[0], Bs[1], tol); EjmlUnitTests.assertEquals(Qs[0], Qs[1], tol); }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void test() { int n = 5; DenseMatrix64F mat = RandomMatrices.createRandom(n, n, new Random()); DenseMatrix64F inverse = new DenseMatrix64F(n, n); CommonOps.invert(mat, inverse); DenseMatrix64F matrixOfCoFactors = MatrixOfCofactorsCalculatorInefficient.computeMatrixOfCoFactors(mat); DenseMatrix64F inverseViaMatrixOfCoFactors = new DenseMatrix64F(matrixOfCoFactors.getNumCols(), matrixOfCoFactors.getNumRows()); CommonOps.transpose(matrixOfCoFactors, inverseViaMatrixOfCoFactors); CommonOps.scale(1.0/CommonOps.det(mat), inverseViaMatrixOfCoFactors); JUnitTools.assertMatrixEquals(inverse, inverseViaMatrixOfCoFactors, 1e-5); }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testScaleTranspose() throws Exception { Random random = new Random(165156L); for (int i = 0; i < 200; i++) { int numRows = RandomNumbers.nextInt(random, 1, 100); int numCols = RandomNumbers.nextInt(random, 1, 100); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(numRows, numCols, 1.0, 100.0, random); double randomAlpha = RandomNumbers.nextDouble(random, 100.0); DenseMatrix64F expectedMatrix = new DenseMatrix64F(numCols, numRows); DenseMatrix64F actualMatrix = new DenseMatrix64F(numCols, numRows); CommonOps.transpose(randomMatrix, expectedMatrix); CommonOps.scale(randomAlpha, expectedMatrix); MatrixTools.scaleTranspose(randomAlpha, randomMatrix, actualMatrix); boolean areMatricesEqual = MatrixFeatures.isEquals(expectedMatrix, actualMatrix, 1.0e-10); assertTrue(areMatricesEqual); } }
@ContinuousIntegrationTest(estimatedDuration = 0.5) @Test(timeout = 50000) public void testPreMultVector() { Random random = new Random(1738L); int iters = 1000; for (int i = 0; i < iters; i++) { int diagonalRows = RandomNumbers.nextInt(random, 1, 100); int interiorCols = RandomNumbers.nextInt(random, 1, 100); int randomCols = RandomNumbers.nextInt(random, 1, 100); DenseMatrix64F diagonal = CommonOps.identity(diagonalRows, interiorCols); DenseMatrix64F diagonalVector = new DenseMatrix64F(diagonalRows, 1); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(interiorCols, randomCols, -5000.0, 5000.0, random); DenseMatrix64F solution = new DenseMatrix64F(diagonalRows, randomCols); DenseMatrix64F otherSolution = new DenseMatrix64F(diagonalRows, randomCols); for (int index = 0; index < Math.min(diagonalRows, interiorCols); index++) { double value = RandomNumbers.nextDouble(random, 5000.0); diagonal.set(index, index, value); diagonalVector.set(index, value); } DiagonalMatrixTools.preMult(diagonalVector, randomMatrix, solution); CommonOps.mult(diagonal, randomMatrix, otherSolution); JUnitTools.assertMatrixEquals(otherSolution, solution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 40000) public void testEasyMultOuter() { Random random = new Random(124L); int iters = 1000; for (int i = 0; i < iters; i++) { int variables = 4; int taskSize = 3; DenseMatrix64F diagonal = CommonOps.identity(taskSize, taskSize); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(variables, taskSize, -50.0, 50.0, random); DenseMatrix64F solution = new DenseMatrix64F(variables, variables); DenseMatrix64F expectedSolution = new DenseMatrix64F(variables, variables); for (int index = 0; index < taskSize; index++) { diagonal.set(index, index, RandomNumbers.nextDouble(random, 50.0)); } DenseMatrix64F tempWJ = new DenseMatrix64F(variables, taskSize); CommonOps.mult(randomMatrix, diagonal, tempWJ); CommonOps.multTransB(tempWJ, randomMatrix, expectedSolution); DiagonalMatrixTools.multOuter(randomMatrix, diagonal, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.3) @Test(timeout = 52000) public void testPostMultVector() { Random random = new Random(1738L); int iters = 1000; for (int i = 0; i < iters; i++) { int leadingRows = RandomNumbers.nextInt(random, 1, 100); int interiorCols = RandomNumbers.nextInt(random, 1, 100); int randomCols = RandomNumbers.nextInt(random, 1, 100); DenseMatrix64F diagonal = CommonOps.identity(interiorCols, randomCols); DenseMatrix64F diagonalVector = new DenseMatrix64F(interiorCols, 1); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(leadingRows, interiorCols, -5000.0, 5000.0, random); DenseMatrix64F solution = new DenseMatrix64F(leadingRows, randomCols); DenseMatrix64F otherSolution = new DenseMatrix64F(leadingRows, randomCols); for (int index = 0; index < Math.min(randomCols, interiorCols); index++) { double value = RandomNumbers.nextDouble(random, 5000.0); diagonal.set(index, index, value); diagonalVector.set(index, 0, value); } DiagonalMatrixTools.postMult(randomMatrix, diagonalVector, solution); CommonOps.mult(randomMatrix, diagonal, otherSolution); JUnitTools.assertMatrixEquals(solution, otherSolution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 40000) public void testEasyMultInner() { Random random = new Random(124L); int iters = 1000; for (int i = 0; i < iters; i++) { int variables = 4; int taskSize = 3; DenseMatrix64F diagonal = CommonOps.identity(taskSize, taskSize); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(taskSize, variables, -50.0, 50.0, random); DenseMatrix64F solution = new DenseMatrix64F(variables, variables); DenseMatrix64F expectedSolution = new DenseMatrix64F(variables, variables); for (int index = 0; index < taskSize; index++) { diagonal.set(index, index, RandomNumbers.nextDouble(random, 50.0)); } DenseMatrix64F tempJtW = new DenseMatrix64F(variables, taskSize); DiagonalMatrixTools.postMultTransA(randomMatrix, diagonal, tempJtW); // Compute: H += J^T W J CommonOps.mult(tempJtW, randomMatrix, expectedSolution); DiagonalMatrixTools.multInner(randomMatrix, diagonal, solution); JUnitTools.assertMatrixEquals(expectedSolution, solution, epsilon); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testInsertFrameTupleIntoEJMLVector() { Random random = new Random(3216516L); for (int i = 0; i < 1000; i++) { int numRows = RandomNumbers.nextInt(random, 3, 100); DenseMatrix64F matrixToTest = RandomMatrices.createRandom(numRows, 1, 1.0, 100.0, random); FramePoint3D framePointToInsert = EuclidFrameRandomTools.nextFramePoint3D(random, ReferenceFrame.getWorldFrame(), 100.0, 100.0, 100.0); int startRowToInsertFrameTuple = RandomNumbers.nextInt(random, 0, numRows - 3); MatrixTools.insertFrameTupleIntoEJMLVector(framePointToInsert, matrixToTest, startRowToInsertFrameTuple); assertEquals(framePointToInsert.getX(), matrixToTest.get(startRowToInsertFrameTuple + 0, 0), 1.0e-10); assertEquals(framePointToInsert.getY(), matrixToTest.get(startRowToInsertFrameTuple + 1, 0), 1.0e-10); assertEquals(framePointToInsert.getZ(), matrixToTest.get(startRowToInsertFrameTuple + 2, 0), 1.0e-10); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testRemoveRow() { Random random = new Random(3216516L); for (int i = 0; i < 20; i++) { int numRows = RandomNumbers.nextInt(random, 1, 100); int numCols = RandomNumbers.nextInt(random, 1, 100); DenseMatrix64F randomMatrix = RandomMatrices.createRandom(numRows, numCols, 1.0, 100.0, random); int indexOfRowToRemove = RandomNumbers.nextInt(random, 0, randomMatrix.getNumRows() - 1); DenseMatrix64F expectedMatrix = new DenseMatrix64F(numRows - 1, numCols); for (int rowIndex = 0; rowIndex < numRows - 1; rowIndex++) { for (int colIndex = 0; colIndex < numCols; colIndex++) { if (rowIndex >= indexOfRowToRemove) expectedMatrix.set(rowIndex, colIndex, randomMatrix.get(rowIndex + 1, colIndex)); else expectedMatrix.set(rowIndex, colIndex, randomMatrix.get(rowIndex, colIndex)); } } DenseMatrix64F matrixToTest = new DenseMatrix64F(randomMatrix); MatrixTools.removeRow(matrixToTest, indexOfRowToRemove); boolean areMatricesEqual = MatrixFeatures.isEquals(expectedMatrix, matrixToTest, 1.0e-10); assertTrue(areMatricesEqual); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testExtractFrameTupleFromEJMLVector() { Random random = new Random(3216516L); for (int i = 0; i < 1000; i++) { int numRows = RandomNumbers.nextInt(random, 3, 100); DenseMatrix64F matrixToExtractFrom = RandomMatrices.createRandom(numRows, 1, 1.0, 100.0, random); FramePoint3D framePointToTest = new FramePoint3D(null, -1.0, -1.0, -1.0); int startRowToExtractFrameTuple = RandomNumbers.nextInt(random, 0, numRows - 3); MatrixTools.extractFrameTupleFromEJMLVector(framePointToTest, matrixToExtractFrom, ReferenceFrame.getWorldFrame(), startRowToExtractFrameTuple); assertEquals(framePointToTest.getReferenceFrame(), ReferenceFrame.getWorldFrame()); assertEquals(framePointToTest.getX(), matrixToExtractFrom.get(startRowToExtractFrameTuple + 0, 0), 1.0e-10); assertEquals(framePointToTest.getY(), matrixToExtractFrom.get(startRowToExtractFrameTuple + 1, 0), 1.0e-10); assertEquals(framePointToTest.getZ(), matrixToExtractFrom.get(startRowToExtractFrameTuple + 2, 0), 1.0e-10); } }