diff --git a/src/main/java/org/apache/commons/math3/genetics/NPointCrossover.java b/src/main/java/org/apache/commons/math3/genetics/NPointCrossover.java
new file mode 100644
index 000000000..7d43abaab
--- /dev/null
+++ b/src/main/java/org/apache/commons/math3/genetics/NPointCrossover.java
@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.genetics;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.math3.exception.DimensionMismatchException;
+import org.apache.commons.math3.exception.MathIllegalArgumentException;
+import org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import org.apache.commons.math3.exception.NumberIsTooLargeException;
+import org.apache.commons.math3.exception.util.LocalizedFormats;
+import org.apache.commons.math3.random.RandomGenerator;
+
+/**
+ * N-point crossover policy. For each iteration a random crossover point is
+ * selected and the first part from each parent is copied to the corresponding
+ * child, and the second parts are copied crosswise.
+ *
+ * Example (2-point crossover):
+ *
+ * -C- denotes a crossover point
+ * -C- -C- -C- -C-
+ * p1 = (1 0 | 1 0 0 1 | 0 1 1) X p2 = (0 1 | 1 0 1 0 | 1 1 1)
+ * \----/ \-------/ \-----/ \----/ \--------/ \-----/
+ * || (*) || || (**) ||
+ * VV (**) VV VV (*) VV
+ * /----\ /--------\ /-----\ /----\ /--------\ /-----\
+ * c1 = (1 0 | 1 0 1 0 | 0 1 1) X c2 = (0 1 | 1 0 0 1 | 0 1 1)
+ *
+ *
+ * This policy works only on {@link AbstractListChromosome}, and therefore it
+ * is parameterized by T. Moreover, the chromosomes must have same lengths.
+ *
+ * @param generic type of the {@link AbstractListChromosome}s for crossover
+ * @since 3.1
+ * @version $Id$
+ */
+public class NPointCrossover implements CrossoverPolicy {
+
+ /** The number of crossover points. */
+ private final int crossoverPoints;
+
+ /**
+ * Creates a new {@link NPointCrossover} policy using the given number of points.
+ *
+ * Note: the number of crossover points must be < chromosome length - 1.
+ * This condition can only be checked at runtime, as the chromosome length is not known in advance.
+ *
+ *
+ * @param crossoverPoints the number of crossover points
+ * @throws NotStrictlyPositiveException if the number of {@code crossoverPoints} is not
+ * strictly positive
+ */
+ public NPointCrossover(final int crossoverPoints) {
+ if (crossoverPoints <= 0) {
+ throw new NotStrictlyPositiveException(crossoverPoints);
+ }
+ this.crossoverPoints = crossoverPoints;
+ }
+
+ /**
+ * Returns the number of crossover points used by this {@link CrossoverPolicy}.
+ *
+ * @return the number of crossover points
+ */
+ public int getCrossoverPoints() {
+ return crossoverPoints;
+ }
+
+ /**
+ * Performs a N-point crossover. N random crossover points are selected and are used
+ * to divide the parent chromosomes into segments. The segments are copied in alternate
+ * order from the two parents to the corresponding child chromosomes.
+ *
+ * Example (2-point crossover):
+ *
+ * -C- denotes a crossover point
+ * -C- -C- -C- -C-
+ * p1 = (1 0 | 1 0 0 1 | 0 1 1) X p2 = (0 1 | 1 0 1 0 | 1 1 1)
+ * \----/ \-------/ \-----/ \----/ \--------/ \-----/
+ * || (*) || || (**) ||
+ * VV (**) VV VV (*) VV
+ * /----\ /--------\ /-----\ /----\ /--------\ /-----\
+ * c1 = (1 0 | 1 0 1 0 | 0 1 1) X c2 = (0 1 | 1 0 0 1 | 0 1 1)
+ *
+ *
+ * @param first first parent (p1)
+ * @param second second parent (p2)
+ * @return pair of two children (c1,c2)
+ * @throws MathIllegalArgumentException iff one of the chromosomes is
+ * not an instance of {@link AbstractListChromosome}
+ * @throws DimensionMismatchException if the length of the two chromosomes is different
+ */
+ @SuppressWarnings("unchecked") // OK because of instanceof checks
+ public ChromosomePair crossover(final Chromosome first, final Chromosome second) {
+ if (!(first instanceof AbstractListChromosome && second instanceof AbstractListChromosome)) {
+ throw new MathIllegalArgumentException(LocalizedFormats.INVALID_FIXED_LENGTH_CHROMOSOME);
+ }
+ return mate((AbstractListChromosome) first, (AbstractListChromosome) second);
+ }
+
+ /**
+ * Helper for {@link #crossover(Chromosome, Chromosome)}. Performs the actual crossover.
+ *
+ * @param first the first chromosome
+ * @param second the second chromosome
+ * @return the pair of new chromosomes that resulted from the crossover
+ * @throws DimensionMismatchException if the length of the two chromosomes is different
+ * @throws NumberIsTooLargeException if the number of crossoverPoints is too large for the
+ * actual chromosomes
+ */
+ private ChromosomePair mate(final AbstractListChromosome first,
+ final AbstractListChromosome second) {
+ final int length = first.getLength();
+ if (length != second.getLength()) {
+ throw new DimensionMismatchException(second.getLength(), length);
+ }
+ if (crossoverPoints >= length) {
+ throw new NumberIsTooLargeException(crossoverPoints, length, false);
+ }
+
+ // array representations of the parents
+ final List parent1Rep = first.getRepresentation();
+ final List parent2Rep = second.getRepresentation();
+ // and of the children
+ final ArrayList child1Rep = new ArrayList(first.getLength());
+ final ArrayList child2Rep = new ArrayList(second.getLength());
+
+ final RandomGenerator random = GeneticAlgorithm.getRandomGenerator();
+
+ ArrayList c1 = child1Rep;
+ ArrayList c2 = child2Rep;
+
+ int remainingPoints = crossoverPoints;
+ int lastIndex = 0;
+ for (int i = 0; i < crossoverPoints; i++, remainingPoints--) {
+ // select the next crossover point at random
+ final int crossoverIndex = 1 + lastIndex + random.nextInt(length - lastIndex - remainingPoints);
+
+ // copy the current segment
+ for (int j = lastIndex; j < crossoverIndex; j++) {
+ c1.add(parent1Rep.get(j));
+ c2.add(parent2Rep.get(j));
+ }
+
+ // swap the children for the next segment
+ ArrayList tmp = c1;
+ c1 = c2;
+ c2 = tmp;
+
+ lastIndex = crossoverIndex;
+ }
+
+ // copy the last segment
+ for (int j = lastIndex; j < length; j++) {
+ c1.add(parent1Rep.get(j));
+ c2.add(parent2Rep.get(j));
+ }
+
+ return new ChromosomePair(first.newFixedLengthChromosome(child1Rep),
+ second.newFixedLengthChromosome(child2Rep));
+ }
+}
diff --git a/src/test/java/org/apache/commons/math3/genetics/NPointCrossoverTest.java b/src/test/java/org/apache/commons/math3/genetics/NPointCrossoverTest.java
new file mode 100644
index 000000000..87ac21d7a
--- /dev/null
+++ b/src/test/java/org/apache/commons/math3/genetics/NPointCrossoverTest.java
@@ -0,0 +1,113 @@
+package org.apache.commons.math3.genetics;
+
+import java.util.List;
+
+import org.apache.commons.math3.exception.DimensionMismatchException;
+import org.apache.commons.math3.exception.MathIllegalArgumentException;
+import org.apache.commons.math3.exception.NumberIsTooLargeException;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NPointCrossoverTest {
+
+ @Test(expected = DimensionMismatchException.class)
+ public void testCrossoverDimensionMismatchException() {
+ final Integer[] p1 = new Integer[] {1,0,1,0,0,1,0,1,1};
+ final Integer[] p2 = new Integer[] {0,1,1,0,1};
+
+ final BinaryChromosome p1c = new DummyBinaryChromosome(p1);
+ final BinaryChromosome p2c = new DummyBinaryChromosome(p2);
+
+ final CrossoverPolicy cp = new NPointCrossover(1);
+ cp.crossover(p1c,p2c);
+ }
+
+ @Test(expected = NumberIsTooLargeException.class)
+ public void testNumberIsTooLargeException() {
+ final Integer[] p1 = new Integer[] {1,0,1,0,0,1,0,1,1};
+ final Integer[] p2 = new Integer[] {0,1,1,0,1,0,1,1,1};
+
+ final BinaryChromosome p1c = new DummyBinaryChromosome(p1);
+ final BinaryChromosome p2c = new DummyBinaryChromosome(p2);
+
+ final CrossoverPolicy cp = new NPointCrossover(15);
+ cp.crossover(p1c,p2c);
+ }
+
+ @Test(expected = MathIllegalArgumentException.class)
+ public void testCrossoverInvalidFixedLengthChromosomeFirst() {
+ final Integer[] p1 = new Integer[] {1,0,1,0,0,1,0,1,1};
+ final BinaryChromosome p1c = new DummyBinaryChromosome(p1);
+ final Chromosome p2c = new Chromosome() {
+ public double fitness() {
+ // Not important
+ return 0;
+ }
+ };
+
+ final CrossoverPolicy cp = new NPointCrossover(1);
+ cp.crossover(p1c,p2c);
+ }
+
+ @Test(expected = MathIllegalArgumentException.class)
+ public void testCrossoverInvalidFixedLengthChromosomeSecond() {
+ final Integer[] p1 = new Integer[] {1,0,1,0,0,1,0,1,1};
+ final BinaryChromosome p2c = new DummyBinaryChromosome(p1);
+ final Chromosome p1c = new Chromosome() {
+ public double fitness() {
+ // Not important
+ return 0;
+ }
+ };
+
+ final CrossoverPolicy cp = new NPointCrossover(1);
+ cp.crossover(p1c,p2c);
+ }
+
+ @Test
+ public void testCrossover() {
+ Integer[] p1 = new Integer[] {1,0,1,0,1,0,1,0,1};
+ Integer[] p2 = new Integer[] {0,1,0,1,0,1,0,1,0};
+
+ BinaryChromosome p1c = new DummyBinaryChromosome(p1);
+ BinaryChromosome p2c = new DummyBinaryChromosome(p2);
+
+ final int order = 3;
+ NPointCrossover npc = new NPointCrossover(order);
+
+ // the two parent chromosomes are different at each position, so it is easy to detect
+ // the number of crossovers that happened for each child
+ for (int i=0; i<20; i++) {
+ ChromosomePair pair = npc.crossover(p1c,p2c);
+
+ Integer[] c1 = new Integer[p1.length];
+ Integer[] c2 = new Integer[p2.length];
+
+ c1 = ((BinaryChromosome) pair.getFirst()).getRepresentation().toArray(c1);
+ c2 = ((BinaryChromosome) pair.getSecond()).getRepresentation().toArray(c2);
+
+ Assert.assertEquals(order, detectCrossoverPoints(p1c, p2c, (BinaryChromosome) pair.getFirst()));
+ Assert.assertEquals(order, detectCrossoverPoints(p2c, p1c, (BinaryChromosome) pair.getSecond()));
+ }
+ }
+
+ private int detectCrossoverPoints(BinaryChromosome p1, BinaryChromosome p2, BinaryChromosome c) {
+ int crossovers = 0;
+ final int length = p1.getLength();
+
+ final List p1Rep = p1.getRepresentation();
+ final List p2Rep = p2.getRepresentation();
+ final List cRep = c.getRepresentation();
+
+ List rep = p1Rep;
+ for (int i = 0; i < length; i++) {
+ if (rep.get(i) != cRep.get(i)) {
+ crossovers++;
+ rep = rep == p1Rep ? p2Rep : p1Rep;
+ }
+ }
+
+ return crossovers;
+ }
+
+}