public static FootstepPlannerType generateRandomPlannerType(Random random) { return values[RandomNumbers.nextInt(random, 0, values.length - 1)]; }
public static FootstepPlanningResult generateRandomResult(Random random) { return values[RandomNumbers.nextInt(random, 0, values.length - 1)]; }
public static Connection getRandomConnection(Random random) { int startId = RandomNumbers.nextInt(random, 0, 100); int targetId = RandomNumbers.nextInt(random, 0, 100); Point3DReadOnly startPoint = EuclidCoreRandomTools.nextPoint3D(random, 50); Point3DReadOnly targetPoint = EuclidCoreRandomTools.nextPoint3D(random, 50); return new Connection(startPoint, startId, targetPoint, targetId); }
public static VisibilityMap getRandomVisibilityMap(Random random) { int numberOfConnections = RandomNumbers.nextInt(random, 2, 100); Set<Connection> connections = new HashSet<>(); for (int i = 0; i < numberOfConnections; i++) connections.add(VisibilityGraphRandomTools.getRandomConnection(random)); VisibilityMap map = new VisibilityMap(connections); return map; }
private static PlanarRegion createRandomPlanarRegion(Random random, int idNumber) { int numberOfVertices = RandomNumbers.nextInt(random, 3, 50); int numberOfPolygons = RandomNumbers.nextInt(random, 1, 5); List<ConvexPolygon2D> polygons = new ArrayList<>(); RigidBodyTransform transform = EuclidCoreRandomTools.nextRigidBodyTransform(random); for (int i = 0; i < numberOfPolygons; i++) { polygons.add(EuclidGeometryRandomTools.nextConvexPolygon2D(random, 10.0, numberOfVertices)); } PlanarRegion planarRegion = new PlanarRegion(transform, polygons); planarRegion.setRegionId(idNumber); return planarRegion; }
public static BoundingBoxesPacket nextBoundingBoxesPacket(Random random) { BoundingBoxesPacket next = new BoundingBoxesPacket(); int boxesToGenerate = random.nextInt(20); for (int i = 0; i < boxesToGenerate; i++) { next.getLabels().add().append(Integer.toHexString(random.nextInt())); next.getBoundingBoxesXCoordinates().add(RandomNumbers.nextInt(random, -1000, 1000)); next.getBoundingBoxesYCoordinates().add(RandomNumbers.nextInt(random, -1000, 1000)); next.getBoundingBoxesWidths().add(RandomNumbers.nextInt(random, 0, 1000)); next.getBoundingBoxesHeights().add(RandomNumbers.nextInt(random, 0, 1000)); } return next; }
private RandomFloatingRevoluteJointChain getRandomFloatingChain(int minNumberOfAxes, int maxNumberOfAxes) { Random random = new Random(519651L); int numberOfAxes = RandomNumbers.nextInt(random, minNumberOfAxes, maxNumberOfAxes); Vector3D[] jointAxes = new Vector3D[numberOfAxes]; for (int i = 0; i < numberOfAxes; i++) { jointAxes[i] = EuclidCoreRandomTools.nextVector3DWithFixedLength(random, 1.0); } RandomFloatingRevoluteJointChain randomFloatingChain = new RandomFloatingRevoluteJointChain(random, jointAxes); randomFloatingChain.nextState(random, JointStateType.CONFIGURATION, JointStateType.VELOCITY); return randomFloatingChain; }
public static VisibilityMapHolder getRandomSingleSourceVisibilityMap(Random random) { int numberOfConnections = RandomNumbers.nextInt(random, 2, 50); Set<Connection> connections = new HashSet<>(); for (int i = 0; i < numberOfConnections; i++) connections.add(VisibilityGraphRandomTools.getRandomConnection(random)); VisibilityMapHolder map = new SingleSourceVisibilityMap(EuclidCoreRandomTools.nextPoint3D(random, 100.0), RandomNumbers.nextInt(random, -100, 100), connections); map.getVisibilityMapInLocal().computeVertices(); map.getVisibilityMapInWorld().computeVertices(); return map; }
private static PlanarRegionsList createRandomPlanarRegionList(Random random) { PlanarRegionsList planarRegionsList = new PlanarRegionsList(); for (int i = 0; i < RandomNumbers.nextInt(random, 1, 50); i++) planarRegionsList.addPlanarRegion(createRandomPlanarRegion(random, i)); return planarRegionsList; }
@ContinuousIntegrationAnnotations.ContinuousIntegrationTest(estimatedDuration = 1.8) @Test(timeout = 30000) public void testConvertSingleSourceVisibilityMap() { Random random = new Random(1738L); for (int iter = 0; iter < iters; iter++) { int numberOfConnections = RandomNumbers.nextInt(random, 2, 100); List<Connection> connections = new ArrayList<>(); for (int i = 0; i < numberOfConnections; i++) connections.add(VisibilityGraphRandomTools.getRandomConnection(random)); VisibilityMapHolder mapToConvert = new SingleSourceVisibilityMap(EuclidCoreRandomTools.nextPoint3D(random, 100.0), RandomNumbers.nextInt(random, -100, 100), connections); VisibilityMapMessage visibilityMapMessage = VisibilityGraphMessagesConverter.convertToVisibilityMapMessage(mapToConvert); VisibilityMapHolder convertedMap = VisibilityGraphMessagesConverter.convertToSingleSourceVisibilityMap(visibilityMapMessage); VisibilityGraphTestTools.assertSingleSourceVisibilityMapHoldersEqual(mapToConvert, convertedMap, epsilon); } }
public static HeatMapPacket nextHeatMapPacket(Random random) { HeatMapPacket next = new HeatMapPacket(); next.setHeight(RandomNumbers.nextInt(random, -100, 100)); next.setWidth(RandomNumbers.nextInt(random, -100, 100)); next.getData().add(RandomNumbers.nextFloatArray(random, next.getHeight() * next.getWidth(), 1.0f)); next.setName(Integer.toHexString(random.nextInt())); return next; }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testSize() { Random random = new Random(10L); for (int i = 0; i < 1000; i++) { int size = RandomNumbers.nextInt(random, 1, 200); int numberOfConstraints = RandomNumbers.nextInt(random, 1, 200); ICPInequalityInput input = new ICPInequalityInput(numberOfConstraints, size); Assert.assertEquals(numberOfConstraints, input.Aineq.numRows); Assert.assertEquals(size, input.Aineq.numCols); Assert.assertEquals(numberOfConstraints, input.bineq.numRows); Assert.assertEquals(1, input.bineq.numCols); } }
public static VisibilityMapHolder getRandomInterRegionVisibilityMap(Random random) { InterRegionVisibilityMap map = new InterRegionVisibilityMap(); int numberOfConnections = RandomNumbers.nextInt(random, 2, 100); Set<Connection> connections = new HashSet<>(); for (int i = 0; i < numberOfConnections; i++) connections.add((VisibilityGraphRandomTools.getRandomConnection(random))); map.addConnections(connections); map.getVisibilityMapInWorld().computeVertices(); map.getVisibilityMapInLocal().computeVertices(); return map; }
@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 testSize() { Random random = new Random(10L); for (int i = 0; i < 1000; i++) { int size = RandomNumbers.nextInt(random, 1, 200); ICPQPInput icpqpInput = new ICPQPInput(size); Assert.assertEquals(size, icpqpInput.quadraticTerm.numRows); Assert.assertEquals(size, icpqpInput.quadraticTerm.numCols); Assert.assertEquals(size, icpqpInput.linearTerm.numRows); Assert.assertEquals(1, icpqpInput.linearTerm.numCols); Assert.assertEquals(1, icpqpInput.residualCost.numRows); Assert.assertEquals(1, icpqpInput.residualCost.numCols); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout = 30000) public void testConstructor() { Random random = new Random(3213620L); RigidBodyTransform expectedTransform = EuclidCoreRandomTools.nextRigidBodyTransform(random); long expectedTimestamp = RandomNumbers.nextInt(random, 132, 51568418); TimeStampedTransform3D toBeTested = new TimeStampedTransform3D(expectedTransform, expectedTimestamp); assertEquals("Timestamp is different from what was expected", expectedTimestamp, toBeTested.getTimeStamp()); assertTrue("Transform is different from what was expected", expectedTransform.epsilonEquals(toBeTested.getTransform3D(), EPSILON)); assertTrue("TimestampedTransform should only copy the given transform into an internal variable", expectedTransform != toBeTested.getTransform3D()); }
@ContinuousIntegrationTest(estimatedDuration = 0.1) @Test(timeout = 30000) public void testReset() { Random random = new Random(10L); for (int i = 0; i < 1000; i++) { int size = RandomNumbers.nextInt(random, 1, 200); int numberOfConstraints = RandomNumbers.nextInt(random, 1, 200); ICPInequalityInput input = new ICPInequalityInput(numberOfConstraints, size); CommonOps.fill(input.Aineq, RandomNumbers.nextDouble(random, -1000.0, 1000.0)); CommonOps.fill(input.bineq, RandomNumbers.nextDouble(random, -1000.0, 1000.0)); Assert.assertNotEquals(CommonOps.elementSum(input.Aineq), 0.0, 1e-7); Assert.assertNotEquals(CommonOps.elementSum(input.bineq), 0.0, 1e-7); input.reset(); Assert.assertEquals(CommonOps.elementSum(input.Aineq), 0.0, 1e-7); Assert.assertEquals(CommonOps.elementSum(input.bineq), 0.0, 1e-7); } }
@ContinuousIntegrationTest(estimatedDuration = 0.0) @Test(timeout=300000) public void testNegativeReferencePositiveInputNoOvershoot() { Random random = new Random(1976L); registry = new YoVariableRegistry("registry"); variable = new DeltaLimitedYoVariable("testVar", registry, 0.0); for(int i = 0; i < 60000; i++) { double reference = RandomNumbers.nextInt(random, RANDOM_LOWER_BOUND, RANDOM_UPPER_BOUND) * -1.0; double input = reference * -0.5; double delta = Math.abs(input - reference); variable.setMaxDelta(delta); variable.updateOutput(reference, input); Assert.assertTrue(input > 0.0); Assert.assertTrue(reference < 0.0); Assert.assertTrue(input > reference); Assert.assertFalse(variable.isLimitingActive()); Assert.assertEquals(input, variable.getDoubleValue(), 1e-8); } }
public static NavigableRegion getRandomNavigableRegion(Random random) { int numberOfObstacleClusters = RandomNumbers.nextInt(random, 1, 50); PlanarRegion homeRegion = nextPlanarRegion(random); Cluster homeCluster = getRandomCluster(random); NavigableRegion navigableRegion = new NavigableRegion(homeRegion); navigableRegion.setHomeRegionCluster(homeCluster); for (int i = 0; i < numberOfObstacleClusters; i++) navigableRegion.addObstacleCluster(getRandomCluster(random)); navigableRegion.setVisibilityMapInLocal(getRandomSingleSourceVisibilityMap(random).getVisibilityMapInLocal()); return navigableRegion; }
@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); } }