Exemple #1
0
  /**
   * @param aChromosome
   * @return double adjusted fitness for aChromosome relative to this specie
   * @throws IllegalArgumentException if chromosome is not a member if this specie
   */
  public double getChromosomeFitnessValue(Chromosome aChromosome) {
    if (aChromosome.getFitnessValue() < 0)
      throw new IllegalArgumentException(
          "chromosome's fitness has not been set: " + aChromosome.toString());
    if (chromosomes.contains(aChromosome) == false)
      throw new IllegalArgumentException(
          "chromosome not a member of this specie: " + aChromosome.toString());

    return ((double) aChromosome.getFitnessValue()) / chromosomes.size();
  }
Exemple #2
0
 /** @return Chromosome fittest in this specie */
 public synchronized Chromosome getFittest() {
   if (fittest == null) {
     Iterator it = chromosomes.iterator();
     fittest = (Chromosome) it.next();
     while (it.hasNext()) {
       Chromosome next = (Chromosome) it.next();
       if (next.getFitnessValue() > fittest.getFitnessValue()) fittest = next;
     }
   }
   return fittest;
 }
Exemple #3
0
  /**
   * @return average raw fitness (i.e., not adjusted for specie size) of all chromosomes in specie
   */
  public double getFitnessValue() {
    long totalRawFitness = 0;
    Iterator iter = chromosomes.iterator();
    while (iter.hasNext()) {
      Chromosome aChromosome = (Chromosome) iter.next();
      if (aChromosome.getFitnessValue() < 0)
        throw new IllegalStateException(
            "chromosome's fitness has not been set: " + aChromosome.toString());
      totalRawFitness += aChromosome.getFitnessValue();
    }

    return (double) totalRawFitness / chromosomes.size();
  }
Exemple #4
0
 /**
  * @return String XML representation of object according to <a
  *     href="http://nevt.sourceforge.net/">NEVT </a>.
  */
 public String toXml() {
   StringBuffer result = new StringBuffer();
   result.append("<").append(SPECIE_TAG).append(" ").append(ID_TAG).append("=\"");
   result.append(getRepresentativeId()).append("\" ").append(COUNT_TAG).append("=\"");
   result.append(getChromosomes().size()).append("\">\n");
   Iterator chromIter = getChromosomes().iterator();
   while (chromIter.hasNext()) {
     Chromosome chromToStore = (Chromosome) chromIter.next();
     result.append("<").append(CHROMOSOME_TAG).append(" ").append(ID_TAG).append("=\"");
     result.append(chromToStore.getId()).append("\" ").append(FITNESS_TAG).append("=\"");
     result.append(chromToStore.getFitnessValue()).append("\" />\n");
   }
   result.append("</").append(SPECIE_TAG).append(">\n");
   return result.toString();
 }
Exemple #5
0
 /**
  * @param aChromosome
  * @return true if chromosome is added, false if chromosome already is a member of this specie
  */
 public boolean add(Chromosome aChromosome) {
   if (!match(aChromosome))
     throw new IllegalArgumentException("chromosome does not match specie: " + aChromosome);
   if (chromosomes.contains(aChromosome)) return false;
   aChromosome.setSpecie(this);
   fittest = null;
   return chromosomes.add(aChromosome);
 }
 /** @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */
 public int compare(Object o1, Object o2) {
   Chromosome c1 = (Chromosome) o1;
   Chromosome c2 = (Chromosome) o2;
   int fitness1 = (isSpeciated ? c1.getSpeciatedFitnessValue() : c1.getFitnessValue());
   int fitness2 = (isSpeciated ? c2.getSpeciatedFitnessValue() : c2.getFitnessValue());
   return isAscending ? fitness1 - fitness2 : fitness2 - fitness1;
 }
  public static void main(String[] args) throws InvalidConfigurationException {

    // Reading data from xml
    try {
      new InputData().readFromFile(XML_TEST_FILENAME);
    } catch (SAXException e) {
      System.out.println(e.getMessage());
    } catch (IOException e) {
      System.out.println(e.getMessage());
    } catch (ParserConfigurationException e) {
      System.out.println(e.getMessage());
    }

    // Configuration conf = new DefaultConfiguration();
    Configuration conf = new Configuration("myconf");
    TimetableFitnessFunction fitnessFunction = new TimetableFitnessFunction();
    InitialConstraintChecker timetableConstraintChecker = new InitialConstraintChecker();

    // Creating genes
    Gene[] testGenes = new Gene[CHROMOSOME_SIZE];
    for (int i = 0; i < CHROMOSOME_SIZE; i++) {
      testGenes[i] =
          new GroupClassTeacherLessonTimeSG(
              conf,
              new Gene[] {
                new GroupGene(conf, 1),
                new ClassGene(conf, 1),
                new TeacherGene(conf, 1),
                new LessonGene(conf, 1),
                new TimeGene(conf, 1)
              });
    }
    System.out.println("==================================");
    // Creating chromosome
    Chromosome testChromosome;
    testChromosome = new Chromosome(conf, testGenes);
    testChromosome.setConstraintChecker(timetableConstraintChecker);
    // Setup configuration
    conf.setSampleChromosome(testChromosome);
    conf.setPopulationSize(POPULATION_SIZE);
    conf.setFitnessFunction(fitnessFunction); // add fitness function

    BestChromosomesSelector myBestChromosomesSelector = new BestChromosomesSelector(conf);
    conf.addNaturalSelector(myBestChromosomesSelector, false);

    conf.setRandomGenerator(new StockRandomGenerator());
    conf.setEventManager(new EventManager());
    conf.setFitnessEvaluator(new DefaultFitnessEvaluator());

    CrossoverOperator myCrossoverOperator = new CrossoverOperator(conf);
    conf.addGeneticOperator(myCrossoverOperator);

    TimetableMutationOperator myMutationOperator = new TimetableMutationOperator(conf);
    conf.addGeneticOperator(myMutationOperator);

    conf.setKeepPopulationSizeConstant(false);

    // Creating genotype
    //        Population pop = new Population(conf, testChromosome);
    //        Genotype population = new Genotype(conf, pop);
    Genotype population = Genotype.randomInitialGenotype(conf);

    System.out.println("Our Chromosome: \n " + testChromosome.getConfiguration().toString());

    System.out.println("------------evolution-----------------------------");

    // Begin evolution
    Calendar cal = Calendar.getInstance();
    start_t = cal.getTimeInMillis();
    for (int i = 0; i < MAX_EVOLUTIONS; i++) {
      System.out.println(
          "generation#: " + i + " population size:" + (Integer) population.getPopulation().size());
      if (population.getFittestChromosome().getFitnessValue() >= THRESHOLD) break;
      population.evolve();
    }
    cal = Calendar.getInstance();
    finish_t = cal.getTimeInMillis();

    System.out.println("--------------end of evolution--------------------");
    Chromosome fittestChromosome = (Chromosome) population.getFittestChromosome();
    System.out.println(
        "-------------The best chromosome---fitness="
            + fittestChromosome.getFitnessValue()
            + "---");
    System.out.println("                Group Class Time");
    for (int i = 0; i < CHROMOSOME_SIZE; i++) {
      GroupClassTeacherLessonTimeSG s =
          (GroupClassTeacherLessonTimeSG) fittestChromosome.getGene(i);
      System.out.println(
          "Gene "
              + i
              + " contains: "
              + (Integer) s.geneAt(GROUP).getAllele()
              + " "
              + (Integer) s.geneAt(CLASS).getAllele()
              + " "
              + (Integer) s.geneAt(TEACHER).getAllele()
              + " "
              + (Integer) s.geneAt(LESSON).getAllele()
              + " "
              + (Integer) s.geneAt(TIME).getAllele());
      // GroupGene gg = (GroupGene)s.geneAt(GROUP);
      // System.out.println("gg's idGroup"+gg.getAllele()+" gg.getGroupSize()"+ gg.getGroupSize() );
    }

    System.out.println("Elapsed time:" + (double) (finish_t - start_t) / 1000 + "s");

    // Display the best solution

    OutputData od = new OutputData();
    od.printToConsole(fittestChromosome);

    // Write population to the disk
    try {
      od.printToFile(population, GENOTYPE_FILENAME, BEST_CHROMOSOME_FILENAME);
    } catch (IOException e) {
      System.out.println("IOException raised! " + e.getMessage());
    }
  }
 /**
  * Returns a copy of this Chromosome. The returned instance can evolve independently of this
  * instance. Note that, if possible, this method will first attempt to acquire a Chromosome
  * instance from the active ChromosomePool (if any) and set its value appropriately before
  * returning it. If that is not possible, then a new Chromosome instance will be constructed and
  * its value set appropriately before returning.
  *
  * @return copy of this Chromosome
  * @throws IllegalStateException instead of CloneNotSupportedException
  * @author Neil Rotstan
  * @author Klaus Meffert
  * @since 1.0
  */
 public synchronized Object clone() {
   // Before doing anything, make sure that a Configuration object
   // has been set on this Chromosome. If not, then throw an
   // IllegalStateException.
   // ------------------------------------------------------------
   if (getConfiguration() == null) {
     throw new IllegalStateException(
         "The active Configuration object must be set on this "
             + "Chromosome prior to invocation of the clone() method.");
   }
   IChromosome copy = null;
   // Now, first see if we can pull a Chromosome from the pool and just
   // set its gene values (alleles) appropriately.
   // ------------------------------------------------------------
   IChromosomePool pool = getConfiguration().getChromosomePool();
   if (pool != null) {
     copy = pool.acquireChromosome();
     if (copy != null) {
       Gene[] genes = copy.getGenes();
       for (int i = 0; i < size(); i++) {
         genes[i].setAllele(getGene(i).getAllele());
       }
     }
   }
   try {
     if (copy == null) {
       // We couldn't fetch a Chromosome from the pool, so we need to create
       // a new one. First we make a copy of each of the Genes. We explicity
       // use the Gene at each respective gene location (locus) to create the
       // new Gene that is to occupy that same locus in the new Chromosome.
       // -------------------------------------------------------------------
       int size = size();
       if (size > 0) {
         Gene[] copyOfGenes = new Gene[size];
         for (int i = 0; i < copyOfGenes.length; i++) {
           copyOfGenes[i] = getGene(i).newGene();
           Object allele = getGene(i).getAllele();
           if (allele != null) {
             IJGAPFactory factory = getConfiguration().getJGAPFactory();
             if (factory != null) {
               ICloneHandler cloner = factory.getCloneHandlerFor(allele, allele.getClass());
               if (cloner != null) {
                 try {
                   allele = cloner.perform(allele, null, this);
                 } catch (Exception ex) {
                   throw new RuntimeException(ex);
                 }
               }
             }
           }
           copyOfGenes[i].setAllele(allele);
         }
         // Now construct a new Chromosome with the copies of the genes and
         // return it. Also clone the IApplicationData object later on.
         // ---------------------------------------------------------------
         if (getClass() == Chromosome.class) {
           copy = new Chromosome(getConfiguration(), copyOfGenes);
         } else {
           copy = (IChromosome) getConfiguration().getSampleChromosome().clone();
           copy.setGenes(copyOfGenes);
         }
       } else {
         if (getClass() == Chromosome.class) {
           copy = new Chromosome(getConfiguration());
         } else {
           copy = (IChromosome) getConfiguration().getSampleChromosome().clone();
         }
       }
     }
     copy.setFitnessValue(m_fitnessValue);
     // Clone constraint checker.
     // -------------------------
     copy.setConstraintChecker(getConstraintChecker());
   } catch (InvalidConfigurationException iex) {
     throw new IllegalStateException(iex.getMessage());
   }
   // Also clone the IApplicationData object.
   // ---------------------------------------
   try {
     copy.setApplicationData(cloneObject(getApplicationData()));
   } catch (Exception ex) {
     throw new IllegalStateException(ex.getMessage());
   }
   // Clone multi-objective object if necessary and possible.
   // -------------------------------------------------------
   if (m_multiObjective != null) {
     if (getClass() == Chromosome.class) {
       try {
         ((Chromosome) copy).setMultiObjectives((List) cloneObject(m_multiObjective));
       } catch (Exception ex) {
         throw new IllegalStateException(ex.getMessage());
       }
     }
   }
   return copy;
 }
Exemple #9
0
 /**
  * Create new specie from representative. Representative is first member of specie, and all other
  * members of specie are determined by compatibility with representative. Even if representative
  * dies from population, a reference is kept here to determine specie membership.
  *
  * @param aSpeciationParms
  * @param aRepresentative
  */
 public Specie(SpeciationParms aSpeciationParms, Chromosome aRepresentative) {
   representative = aRepresentative;
   aRepresentative.setSpecie(this);
   chromosomes.add(aRepresentative);
   speciationParms = aSpeciationParms;
 }
Exemple #10
0
 /** @return unique ID; this is chromosome ID of representative */
 public Long getRepresentativeId() {
   return representative.getId();
 }
Exemple #11
0
 /** @see java.lang.Object#equals(java.lang.Object) */
 public boolean equals(Object o) {
   Specie other = (Specie) o;
   return representative.equals(other.representative);
 }
Exemple #12
0
 /** @see java.lang.Object#hashCode() */
 public int hashCode() {
   return representative.hashCode();
 }
Exemple #13
0
 /**
  * @param aChromosome
  * @return boolean true iff compatibility difference between
  * <code>aChromosome</code? and representative
  * is less than speciation threshold
  */
 public boolean match(Chromosome aChromosome) {
   return (representative.distance(aChromosome, speciationParms)
       < speciationParms.getSpeciationThreshold());
 }