Merge pull request #112 from cicirello/permutation-mechanic-updates

Permutation.Mechanic updates

Author: cicirello

CHANGELOG.md

@@ -4,9 +4,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased] - 2021-03-29
+## [Unreleased] - 2021-03-31
 
 ### Added
+* Added the `Permutation.Mechanic.set(Permutation, int[], int, int, int)` method.
 
 ### Changed
 

src/org/cicirello/permutations/Permutation.java

@@ -38,7 +38,7 @@
  * manipulate permutations in a variety of ways.
  * 
  * @author <a href=https://www.cicirello.org/ target=_top>Vincent A. Cicirello</a>, <a href=https://www.cicirello.org/ target=_top>https://www.cicirello.org/</a> 
- * @version 3.29.2021
+ * @version 3.31.2021
  */
 public final class Permutation implements Serializable, Iterable<Permutation>, Copyable<Permutation> {
 
@@ -934,7 +934,7 @@ public int hashCode() {
 	 * that public method is expected to ensure that the Permutation is fully valid before returning.</p>
 	 *
 	 * @author <a href=https://www.cicirello.org/ target=_top>Vincent A. Cicirello</a>, <a href=https://www.cicirello.org/ target=_top>https://www.cicirello.org/</a> 
-	 * @version 3.29.2021
+	 * @version 3.31.2021
 	 */
 	public static class Mechanic {
 
@@ -990,5 +990,24 @@ protected final void set(Permutation p, int index, int value) {
 		protected final void set(Permutation p, int index, int[] subpermutation) {
 			System.arraycopy(subpermutation, 0, p.permutation, index, subpermutation.length);
 		}
+		
+		/**
+		 * Changes a range of permutation elements.  This method does not verify that the
+		 * change produces a valid permutation.  The caller is responsible for making a combination
+		 * of calls to this method and/or the other methods of the Permutation.Mechanic class that
+		 * together produce a valid Permutation.   
+		 * The behavior of the Permutation object may become unstable otherwise.
+		 * The caller should not return until the state of the Permutation object is again valid.
+		 *
+		 * @param p Permutation object to change.
+		 * @param source An array to copy elements from.
+		 * @param fromIndex An index into source where copying begins, e.g., the first element
+		 * copied is source[fromIndex].
+		 * @param toIndex An index into the Permutation p, where the elements will be copied to.
+		 * @param numElementsToSet The number of elements to copy from source to p. 
+		 */
+		protected final void set(Permutation p, int[] source, int fromIndex, int toIndex, int numElementsToSet) {
+			System.arraycopy(source, fromIndex, p.permutation, toIndex, numElementsToSet);
+		}
 	}
 }

tests/org/cicirello/permutations/PermutationTestCases.java

@@ -237,6 +237,9 @@ public void testSet(Permutation p, int i, int v) {
 			public void testSet(Permutation p, int i, int[] a) {
 				set(p, i, a);
 			}
+			public void testSet(Permutation p, int[] s, int from, int to, int numElements) {
+				set(p, s, from, to, numElements);
+			}
 		}
 		MyMech test = new MyMech();
 
@@ -276,6 +279,42 @@ public void testSet(Permutation p, int i, int[] a) {
 				assertEquals("elements after end should not change", a[i], p.get(i));
 			}
 		}
+		for (int[] a : arrays) {
+			Permutation p = new Permutation(a.length, 0);
+			test.testSet(p, a.clone(), 0, 0, a.length); 
+			validatePermutation(p, a.length);
+			for (int i = 0; i < a.length; i++) assertEquals("elements should be in same order", a[i], p.get(i));
+		}
+		for (int[] a : arrays) {
+			Permutation p = new Permutation(a);
+			int[] change = a.length > 2 ? new int[] {7, 5} : new int[] {7};
+			int start = a.length > 1 ? 1 : 0;
+			test.testSet(p, change, 0, start, change.length);
+			for (int i = 0; i < start; i++) {
+				assertEquals("elements before start should not change", a[i], p.get(i));
+			}
+			for (int i = 0; i < change.length; i++) {
+				assertEquals("checking changed elements", change[i], p.get(start+i));
+			}
+			for (int i = start + change.length; i < a.length; i++) {
+				assertEquals("elements after end should not change", a[i], p.get(i));
+			}
+		}
+		for (int[] a : arrays) {
+			Permutation p = new Permutation(a);
+			int[] change = a.length > 2 ? new int[] {9, 9, 7, 5, 9, 9} : new int[] {9, 9, 7, 9, 9};
+			int start = a.length > 1 ? 1 : 0;
+			test.testSet(p, change, 2, start, change.length - 4);
+			for (int i = 0; i < start; i++) {
+				assertEquals("elements before start should not change", a[i], p.get(i));
+			}
+			for (int i = 2; i < change.length-2; i++) {
+				assertEquals("checking changed elements", change[i], p.get(start+i-2));
+			}
+			for (int i = start + change.length - 4; i < a.length; i++) {
+				assertEquals("elements after end should not change", a[i], p.get(i));
+			}
+		}
 	}
 
 	@Test