org.cicirello.search.operators.permutations.BlockMoveMutation Maven / Gradle / Ivy
Show all versions of chips-n-salsa Show documentation
/*
* Chips-n-Salsa: A library of parallel self-adaptive local search algorithms.
* Copyright (C) 2002-2021 Vincent A. Cicirello
*
* This file is part of Chips-n-Salsa (https://chips-n-salsa.cicirello.org/).
*
* Chips-n-Salsa 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.
*
* Chips-n-Salsa 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 this program. If not, see A block move is sometimes also called a block transposition, and can be described equivalently
* as swapping two adjacent blocks. Consider the permutation: p1 = [0, 1, 2, 3, 4, 5, 6, 7]. Now
* consider a block move that consists in removing block [4, 5, 6] and reinserting it at index 2.
* The result is p2 = [0, 1, 4, 5, 6, 2, 3, 7]. This can be described equivalently as swapping the
* two adjacent blocks [4, 5, 6] and [2, 3]. This mutation operator is related to the {@link
* BlockInterchangeMutation}, which swaps a pair of randomly selected non-overlapping blocks.
*
*
The runtime (worst case and average case) of both the {@link #mutate(Permutation) mutate} and
* {@link #undo(Permutation) undo} methods is O(n), where n is the length of the permutation. The
* worst case runtime occurs when the removed block is at one end of the permutation, and reinserted
* at the opposite end, which causes all n permutation elements to move. On average, a block move
* affects n/2 element locations.
*
* @author Vincent A. Cicirello, https://www.cicirello.org/
*/
public class BlockMoveMutation
implements UndoableMutationOperator, IterableMutationOperator {
// needed to implement undo
private final int[] indexes;
/** Constructs a BlockMoveMutation mutation operator. */
public BlockMoveMutation() {
indexes = new int[3];
}
@Override
public final void mutate(Permutation c) {
if (c.length() >= 2) {
generateIndexes(c.length(), indexes);
c.removeAndInsert(indexes[1], indexes[2] - indexes[1] + 1, indexes[0]);
}
}
@Override
public final void undo(Permutation c) {
c.removeAndInsert(indexes[0], indexes[2] - indexes[1] + 1, indexes[1]);
}
@Override
public BlockMoveMutation split() {
return new BlockMoveMutation();
}
/**
* {@inheritDoc}
*
* The worst case runtime of the {@link MutationIterator#hasNext} and the {@link
* MutationIterator#setSavepoint} methods of the {@link MutationIterator} created by this method
* is O(1). The amortized runtime of the {@link MutationIterator#nextMutant} method is O(1). And
* the worst case runtime of the {@link MutationIterator#rollback} method is O(n), where n is the
* length of the Permutation.
*/
@Override
public MutationIterator iterator(Permutation p) {
return new BlockMoveIterator(p);
}
/*
* This package access method allows the window limited version
* implemented as a subclass to change how indexes are generated
* without modifying the mutate method.
*/
void generateIndexes(int n, int[] indexes) {
// Note 1: The nextIntTriple method returns 3 all different indexes,
// but a removed block of length 1 would require 2 identical indexes.
// To handle this, add 1 to n, and map an index beyond end of permutation
// to the block length 1 case.
// Note 2: Without loss of generality, the indexes are generated to
// move the block earlier in the permutation. We can do this because
// a "block move" essentially swaps two adjacent "blocks."
RandomIndexer.nextIntTriple(n + 1, indexes, true);
if (indexes[2] == n) indexes[2] = indexes[1];
}
}