View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.math.genetics;
18  
19  import java.util.ArrayList;
20  import java.util.Arrays;
21  import java.util.Collections;
22  import java.util.List;
23  
24  /**
25   * Chromosome represented by an immutable list of a fixed length.
26   * 
27   * @param <T> type of the representation list
28   * @version $Revision: 799857 $ $Date: 2009-08-01 09:07:12 -0400 (Sat, 01 Aug 2009) $
29   * @since 2.0
30   */
31  public abstract class AbstractListChromosome<T> extends Chromosome {
32      
33      /** List representing the chromosome */
34      private final List<T> representation;
35      
36      /**
37       * Constructor.
38       * @param representation inner representation of the chromosome
39       */
40      public AbstractListChromosome(final List<T> representation) {
41          try {
42              checkValidity(representation);
43          } catch (InvalidRepresentationException e) {
44              throw new IllegalArgumentException(String.format("Invalid representation for %s", getClass().getSimpleName()), e);
45          }
46          this.representation = Collections.unmodifiableList(new ArrayList<T> (representation));
47      }
48      
49      /**
50       * Constructor.
51       * @param representation inner representation of the chromosome
52       */
53      public AbstractListChromosome(final T[] representation) {
54          this(Arrays.asList(representation));
55      }
56  
57      /**
58       * 
59       * Asserts that <code>representation</code> can represent a valid chromosome.
60       * @param representation representation of the chromosome
61       * @throws InvalidRepresentationException iff the <code>representation</code> can not represent
62       *         a valid chromosome
63       */
64      protected abstract void checkValidity(List<T> representation) throws InvalidRepresentationException;
65  
66      /**
67       * Returns the (immutable) inner representation of the chromosome.
68       * @return the representation of the chromosome
69       */
70      protected List<T> getRepresentation() {
71          return representation;
72      }
73  
74      /**
75       * Returns the length of the chromosome.
76       * @return the length of the chromosome
77       */
78      public int getLength() {
79          return getRepresentation().size();
80      }
81  
82      /**
83       * Creates a new instance of the same class as <code>this</code> is, with a
84       * given <code>arrayRepresentation</code>. This is needed in crossover and
85       * mutation operators, where we need a new instance of the same class, but
86       * with different array representation.
87       * 
88       * Usually, this method just calls a constructor of the class.
89       * 
90       * @param representation
91       *            the inner array representation of the new chromosome.
92       * @return new instance extended from FixedLengthChromosome with the given
93       *         arrayRepresentation
94       */
95      public abstract AbstractListChromosome<T> newFixedLengthChromosome(final List<T> representation);
96      
97      /**
98       * {@inheritDoc}
99       */
100     @Override
101     public String toString() {
102         return String.format("(f=%s %s)", getFitness(), getRepresentation());
103     }
104 }