Merge pull request #214 from cicirello/cycle-edit-distance

Added implementation of cycle edit distance

Author: cicirello

CHANGELOG.md

@@ -4,10 +4,11 @@ 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] - 2022-05-31
+## [Unreleased] - 2022-06-01
 
 ### Added
 * CycleDistance: implementation of cycle distance described in https://doi.org/10.3390/app12115506
+* CycleEditDistance: implementation of cycle edit distance described in https://doi.org/10.3390/app12115506
 
 ### Changed
 

src/main/java/org/cicirello/permutations/distance/CycleEditDistance.java

@@ -0,0 +1,103 @@
+/*
+ * JavaPermutationTools: A Java library for computation on permutations and sequences
+ * Copyright 2005-2022 Vincent A. Cicirello, <https://www.cicirello.org/>.
+ *
+ * This file is part of JavaPermutationTools (https://jpt.cicirello.org/).
+ *
+ * JavaPermutationTools is free software: you can 
+ * redistribute it and/or modify it under the terms of the GNU 
+ * General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your 
+ * option) any later version.
+ *
+ * JavaPermutationTools is distributed in the hope 
+ * that it will be useful, but WITHOUT ANY WARRANTY; without even 
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A 
+ * PARTICULAR PURPOSE.  See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with JavaPermutationTools.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.cicirello.permutations.distance;
+
+import org.cicirello.permutations.Permutation;
+
+/**
+ * <p>Cycle edit distance is the minimum number of non-singleton permutation cycles
+ * necessary to transform permutation p1 into p2. If p1 equals p2, then this distance
+ * is 0. If p1 and p2 have a single permutation cycle, then this distance is clearly 1
+ * since the inverse of that cycle will produce n fixed points. Otherwise, this distance
+ * is equal to 2 since it can be shown that at most 2 permutation cycle operations are
+ * necessary to transform any permutation of length n into any other. Cycle edit distance
+ * satisfies all of the metric properties.</p>
+ *
+ * <p>Cycle edit distance was introduced in the following article:</p>
+ *
+ * <p>Vincent A. Cicirello. 2022. <a href="https://www.cicirello.org/publications/applsci-12-05506.pdf">Cycle 
+ * Mutation: Evolving Permutations via Cycle Induction</a>, <i>Applied Sciences</i>, 12(11), Article 5506 (June 2022). 
+ * doi:<a href="https://doi.org/10.3390/app12115506">10.3390/app12115506</a></p>
+ *
+ * <p>Runtime: O(n), where n is the permutation length.</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>
+ */
+public final class CycleEditDistance implements NormalizedPermutationDistanceMeasurer {
+	
+	/**
+	 * Constructs the distance measurer as specified in the class documentation.
+	 */
+	public CycleEditDistance() {
+
+	}
+	
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @throws IllegalArgumentException if p1.length() is not equal to p2.length().
+	 */
+    @Override
+	public int distance(Permutation p1, Permutation p2) {
+		if (p1.length() != p2.length()) {
+			throw new IllegalArgumentException("Permutations must be the same length");
+		}
+        boolean[] used = new boolean[p1.length()];
+		for (int k = 0; k < used.length; k++) {
+			if (p1.get(k) == p2.get(k)) {
+				used[p1.get(k)] = true;
+			}
+		}
+		int i = 0;
+		for (i = 0; i < used.length; i++) {
+			if (!used[p1.get(i)]) { 
+				break; 
+			}  
+        }
+		
+		if (i >= used.length) {
+			return 0;
+		} else {
+			int[] invP1 = p1.getInverse();
+			int iLast = i;
+		
+			int j = p1.get(i);
+			while (!used[j]) {
+				used[j] = true;
+				j = p2.get(i);
+				i = invP1[j];
+            }
+			for (i = iLast + 1; i < used.length; i++) {
+				if (!used[p1.get(i)]) {  
+					return 2; 
+				}
+			}
+			return 1;
+		}
+	}
+	
+	@Override
+	public int max(int length) {
+		return length >= 4 ? 2 : (length >= 2 ? 1 :0);
+	}
+}

src/test/java/org/cicirello/permutations/distance/PermutationDistanceMaxTests.java

@@ -226,6 +226,16 @@ public void testCycleDistance() {
 		}
 	}
 
+	@Test
+	public void testCycleEditDistance() {
+		CycleEditDistance d = new CycleEditDistance();
+		for (int n = 0; n <= 7; n++) {
+			int expected = bruteForceComputeMax(d,n);
+			assertEquals(expected, d.max(n), "Failed on length: " + n);
+			assertEquals(1.0*expected, d.maxf(n), EPSILON, "Failed on length: " + n);
+		}
+	}
+	
 	//@Test // uncomment if we implement
 	public void testEditDistance() {
 		/* // Uncomment if we implement. 

src/test/java/org/cicirello/permutations/distance/PermutationDistanceNormTests.java

@@ -167,6 +167,14 @@ public void testCycleDistance() {
 		}
 	}
 
+	@Test
+	public void testCycleEditDistance() {
+		CycleEditDistance d = new CycleEditDistance();
+		for (int n = 0; n <= 7; n++) {
+			assertEquals(n<=1 ? 0.0 : 1.0, bruteForceComputeMax(d,n), EPSILON, "Failed on length: " + n);
+		}
+	}
+	
 	//@Test // uncomment if we implement
 	public void testEditDistance() {
 		/* // Uncomment if we implement. 

src/test/java/org/cicirello/permutations/distance/PermutationDistanceTests.java

@@ -811,9 +811,42 @@ public void testCycleDistance() {
 			{1, 2, 3, 4, 5, 6, 7, 0},
 			{7, 1, 2, 3, 4, 5, 6, 0},
 			{7, 1, 5, 3, 4, 2, 6, 0},
-			{7, 6, 5, 4, 3, 2, 1, 0}
+			{7, 6, 5, 4, 3, 2, 1, 0},
+			{2, 3, 4, 5, 0, 1, 7, 6},
+			{15, 3, 4, 5, 6, 1, 7, 2, 9, 10, 11, 8, 13, 14, 12, 0} 
 		};
-		int[] expected = {1, 1, 1, 2, 1, 1, 2, 4};
+		int[] expected = {1, 1, 1, 2, 1, 1, 2, 4, 3, 5};
+		for (int i = 0; i < expected.length; i++) {
+			Permutation p1 = new Permutation(cases[i].length, 0);
+			Permutation p2 = new Permutation(cases[i]);
+			assertEquals(expected[i], d.distance(p1, p2));
+			assertEquals(expected[i], d.distance(p2, p1));
+		}
+		IllegalArgumentException thrown = assertThrows( 
+			IllegalArgumentException.class,
+			() -> d.distance(new Permutation(1), new Permutation(2))
+		);
+	}
+	
+	@Test
+	public void testCycleEditDistance() {
+		CycleEditDistance d = new CycleEditDistance();
+		identicalPermutations(d);
+		int[][] cases = {
+			{1, 0},
+			{1, 2, 0},
+			{1, 2, 3, 0},
+			{1, 0, 3, 2},
+			{1, 2, 3, 4, 5, 6, 7, 0},
+			{7, 1, 2, 3, 4, 5, 6, 0},
+			{7, 1, 5, 3, 4, 2, 6, 0},
+			{7, 6, 5, 4, 3, 2, 1, 0},
+			{2, 3, 4, 5, 0, 1, 7, 6},
+			{15, 3, 4, 5, 6, 1, 7, 2, 9, 10, 11, 8, 13, 14, 12, 0},
+			{0, 1},
+			{0}
+		};
+		int[] expected = {1, 1, 1, 2, 1, 1, 2, 2, 2, 2, 0, 0};
 		for (int i = 0; i < expected.length; i++) {
 			Permutation p1 = new Permutation(cases[i].length, 0);
 			Permutation p2 = new Permutation(cases[i]);