Added toArray, invert, getInverseP methods to Permutation class

Author: cicirello

lib/jpt1.jar

@@ -251,7 +251,7 @@ public BigInteger toBigInteger() {
 		return result;
 	}
 
-	 /**
+	/**
 	 * Computes the inverse of the permutation.
 	 *
 	 * @return The inverse of the permutation, such that for all i, if
@@ -265,6 +265,31 @@ public int[] getInverse() {
 		return inverse;
 	}  
 
+	/**
+	 * Computes a Permutation that is the inverse of this Permutation.
+	 * Specifically, this.get(i) == j iff inverse.get(j) == i.
+	 *
+	 * @return The inverse of the permutation, such that for all i,
+	 * this.get(i) == j iff inverse.get(j) == i. 
+	 * @since 1.3
+	 */
+	public Permutation getInversePermutation() {
+		return new Permutation(getInverse());
+	}
+	
+	/**
+	 * Inverts the Permutation, such that if p1 is the Permutation immediately
+	 * prior to the call to invert, and if p2 is the Permutation immediately after
+	 * the call to invert, then p1.get(i) == j iff p2.get(j) == i, for all i, j.
+	 * @since 1.3
+	 */
+	public void invert() {
+		int[] inverse = getInverse();
+		for (int i = 0; i < inverse.length; i++) {
+			permutation[i] = inverse[i];
+		}
+	}
+	
 	/**
 	 * Randomly shuffles the permutation. Uses
 	 * java.util.concurrent.ThreadLocalRandom as 
@@ -387,6 +412,20 @@ public int get(int i) {
 		return permutation[i];
 	}
 
+	/**
+	 * Generates an array of int values from the interval [0, n) in the same order
+	 * that they occur in this Permutation.  The array that is returned is independent of
+	 * the object state (i.e., changes to its contents will not affect the Permutation).
+	 *
+	 * @return an int array containing the Permutation elements in the same order that they appear in
+	 * the Permutation.
+	 *
+	 * @since 1.3
+	 */
+	public int[] toArray() {
+		return permutation.clone();
+	}
+	
 	/**
 	 * Retrieves the length of the permutation.
 	 * @return length of the permutation

src/org/cicirello/permutations/Permutation.java

@@ -210,15 +210,61 @@ public void testPermutationEquals() {
 
 	@Test
 	public void testPermutationInverse() {
-		Permutation p = new Permutation(new int[] {4, 2, 5, 0, 3, 1});
+		int[] before = {4, 2, 5, 0, 3, 1};
+		int[] beforeCopy = before.clone();
+		Permutation p = new Permutation(before);
 		int[] expected = {3, 5, 1, 4, 0, 2};
 		int[] inv = p.getInverse();
 		assertArrayEquals("inverse", expected, inv);
+		assertArrayEquals("confirm inverse didn't change original", beforeCopy, before);
 		int[] array = {0, 1, 2, 3, 4, 5};
 		p = new Permutation(array);
 		assertArrayEquals("inverse", array, p.getInverse());
 	}
 
+	@Test
+	public void testPermutationInverseP() {
+		int[] before = {4, 2, 5, 0, 3, 1};
+		Permutation p = new Permutation(before);
+		Permutation p2 = new Permutation(before);
+		int[] expected = {3, 5, 1, 4, 0, 2};
+		Permutation pExpected = new Permutation(expected);
+		Permutation inv = p.getInversePermutation();
+		assertEquals("inverse", pExpected, inv);
+		assertEquals("confirm inverse didn't change original", p2, p);
+		int[] array = {0, 1, 2, 3, 4, 5};
+		p = new Permutation(array);
+		assertEquals("inverse", p, p.getInversePermutation());
+	}
+	
+	@Test
+	public void testPermutationInvert() {
+		int[] before = {4, 2, 5, 0, 3, 1};
+		Permutation p = new Permutation(before);
+		int[] expected = {3, 5, 1, 4, 0, 2};
+		Permutation pExpected = new Permutation(expected);
+		p.invert();
+		assertEquals("inverse", pExpected, p);
+		int[] array = {0, 1, 2, 3, 4, 5};
+		p = new Permutation(array);
+		pExpected = new Permutation(array);
+		p.invert();
+		assertEquals("inverse", pExpected, p);
+	}
+	
+	@Test
+	public void testToArray() {
+		int[] init = {4, 2, 5, 0, 3, 1};
+		Permutation p = new Permutation(init);
+		int[] array = p.toArray();
+		assertArrayEquals("should be equal to current state", init, array);
+		for (int i = 0; i < array.length; i++) {
+			// change the array to confirm did not affect Permutation
+			array[i] = i;
+		}
+		assertArrayEquals("should still be equal to current state", init, p.toArray());
+	}
+	
 	@Test
 	public void testPermutationRemoveInsert() {
 		Permutation p = new Permutation(5);