Previously unsafe constructor now safe.

Redefined the partial copy constructor's behavior such that it always
produces a valid permutation.

Author: cicirello

lib/jpt1.jar

@@ -105,6 +105,8 @@ public Permutation(int n, int value) {
 	/**
 	 * Initializes a permutation of n integers to be identical to the elements of an array.
      * @param p An array of integers. Each of the integers in the interval [0, p.length) must occur exactly one time each.
+	 * @throws IllegalArgumentException if p either contains duplicates, or contains any negative elements, 
+	 *         or contains any elements equal or greater than p.length.
 	 */
 	public Permutation(int[] p) {
 		boolean[] inP = new boolean[p.length];
@@ -127,16 +129,27 @@ public Permutation(Permutation p) {
     }
 
     /**
-     * Initializes a permutation of integers to be identical to a subset of a given
-     * permutation.  Note: if the desired length is less than the source permutation,
-	 * then the resulting permutation will not contain all of the integers in [0,n).
-     * @param p the given permutation.
-     * @param length size of sub-permutation
+     * Initializes a permutation of the integers in the interval [0, length) based on their relative order
+	 * in a permutation p.  If length is greater than or equal to p.length, then this constructor generates a copy of p.
+	 * If length is less than p.length, then the new permutation contains the integers, 0, 1, 2, ..., (length - 1), in the 
+	 * order that those elements appear in p.  For example, if p is the permutation [ 5, 3, 7, 2, 6, 1, 0, 8, 4] and if length
+	 * is 4, this constructor will generate the permutation [3, 2, 1, 0] since 3 appears prior to 2, 2 appears prior to 1, and 1
+	 * appears prior to 0 in permutation p.
+     *
+     * @param p the source permutation.
+     * @param length size of new permutation
      */
     public Permutation(Permutation p, int length) {
 		if (length > p.permutation.length) length = p.permutation.length;
+		else if (length < 0) length = 0;
         permutation = new int[length];
-        System.arraycopy(p.permutation, 0, permutation, 0, length);
+        int k = 0;
+		for (int i = 0; i < p.permutation.length && k < length; i++) {
+			if (p.permutation[i] < length) {
+				permutation[k] = p.permutation[i];
+				k++;
+			}
+		}
     }
 
 

src/org/cicirello/permutations/Permutation.java

@@ -106,11 +106,26 @@ public void testPermutationCopyConstructor() {
 
 	@Test
 	public void testPermutationConstructorCopyPartial() {
-		for (int n = 5, m = 2; n <= 10; n++, m++) {
-			Permutation p = new Permutation(n);
-			Permutation copy = new Permutation(p, m);
-			assertEquals("partial copy length", m, copy.length());
-			for (int i = 0; i < m; i++) assertEquals("elements should be in same order", p.get(i), copy.get(i));
+		for (int n = 1; n <= 10; n++) {
+			int[] forward = new int[n];
+			int[] backward = new int[n];
+			for (int i = 0; i < n; i++) {
+				backward[n-1-i] = forward[i] = i;
+			}
+			Permutation p1 = new Permutation(forward);
+			Permutation p2 = new Permutation(backward);
+			for (int m = 0; m <= n; m++) {
+				Permutation copy1 = new Permutation(p1, m);
+				Permutation copy2 = new Permutation(p2, m);
+				assertEquals("partial copy length", m, copy1.length());
+				assertEquals("partial copy length", m, copy2.length());
+				validatePermutation(copy1, m);
+				validatePermutation(copy2, m);
+				for (int i = 0; i < m; i++) {
+					assertEquals("should be sorted order", i, copy1.get(i));
+					assertEquals("should be reverse sorted order", m-1-i, copy2.get(i));
+				}
+			}
 		}
 	}