import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Applies all GeneticOperators registered with the Configuration. The
 * chromosomes created by the operators are collected in a new Population
 * instance, which is returned.
 * 
 * @param a_config
 *            the configuration to use
 * @param a_pop
 *            the population to use as input
 * @return a new Population instance containing the new Chromosomes
 * 
 * @author Klaus Meffert
 * @author Tamas Mahr
 * @since 3.2
 */
@SuppressWarnings("rawtypes")
protected Population useGeneticOperators(Configuration a_config, Population a_pop) {
	try {
		Population newGeneration = new Population(a_config, a_pop.size());

		List geneticOperators = a_config.getGeneticOperators();
		Iterator operatorIterator = geneticOperators.iterator();
		while (operatorIterator.hasNext()) {
			GeneticOperator operator = (GeneticOperator) operatorIterator.next();
			/**@todo utilize jobs: integrate job into GeneticOperator*/
			operator.operate(a_pop, newGeneration.getChromosomes());
		}

		return newGeneration;
	} catch (InvalidConfigurationException e){
		// should never happen
		throw new IllegalStateException(e);
	}
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Constructs a new instance of this CrossoverOperator with the given
 * crossover rate.
 *
 * @param a_configuration the configuration to use
 * @param a_desiredCrossoverRate the desired rate of crossover
 * @param a_allowFullCrossOver true: x-over before AND after x-over point,
 * false: only x-over after x-over point
 * @throws InvalidConfigurationException
 * @param a_xoverNewAge true: also x-over chromosomes with age of zero (newly
 * created chromosomes)
 *
 * @author Klaus Meffert
 * @since 3.3.2
 */
public MyCrossoverOperator(final Configuration a_configuration,
                         final int a_desiredCrossoverRate,
                         final boolean a_allowFullCrossOver,
                         final boolean a_xoverNewAge)
    throws InvalidConfigurationException {
  super(a_configuration);
  if (a_desiredCrossoverRate < 1) {
    throw new IllegalArgumentException("Crossover rate must be greater zero");
  }
  m_crossoverRate = a_desiredCrossoverRate;
  m_crossoverRatePercent = -1;
  setCrossoverRateCalc(null);
  setAllowFullCrossOver(a_allowFullCrossOver);
  setXoverNewAge(a_xoverNewAge);
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * @param args
 * @throws Exception
 */
public static void main( String[] args ) throws Exception {
	System.out.println( Copyright.STRING );
	if ( args.length < 2 )
		System.err
				.println( "usage: <cmd> <properties-file> <chromosome1-id> [<chromosome2-id> <chromosome3-id> ...]" );

	Properties props = new Properties( args[ 0 ] );
	IdentifyImageFitnessFunction iiff = new IdentifyImageFitnessFunction();
	iiff.init( props );
	FilePersistence db = new FilePersistence();
	db.init( props );

	Configuration config = new DummyConfiguration();
	ArrayList chroms = new ArrayList();
	for ( int i = 1; i < args.length; ++i ) {
		Chromosome chrom = db.loadChromosome( args[ i ], config );
		chroms.add( chrom );
	}
	int fitness = ( chroms.size() > 1 ) ? iiff.evaluateEnsemble( chroms ) : iiff
			.evaluate( (Chromosome) chroms.get( 0 ) );
	System.out
			.println( "fitness = " + fitness + " / " + IdentifyImageFitnessFunction.MAX_FITNESS );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Construct new <code>Genotype</code> object from population in specified run XML data.
 * 
 * @param runXml XML data from which to construct initial population
 * @return new <code>Genotype</code>
 * @throws Exception
 */
private Genotype genotypeFromRunXml( InputStream runXml, Configuration config )
		throws Exception {
	DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
	Document doc = builder.parse( runXml, baseDir.getAbsolutePath() );
	Node runNode = doc.getFirstChild();
	if ( XmlPersistableRun.RUN_TAG.equals( runNode.getNodeName() ) == false )
		throw new IllegalArgumentException( "node name not " + XmlPersistableRun.RUN_TAG );

	// loop through list to find last generation
	Node generationNode = null;
	for ( int i = 0; i < runNode.getChildNodes().getLength(); ++i ) {
		Node nextNode = runNode.getChildNodes().item( i );
		if ( Generation.GENERATION_TAG.equals( nextNode.getNodeName() ) )
			generationNode = nextNode;
	}

	return genotypeFromXml( generationNode, config, this );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Crossover according to <a
 * href="http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf">NEAT </a> crossover
 * methodology.
 * 
 * @param config
 * @param dominantChrom dominant parent
 * @param recessiveChrom recessive parent
 * @return ChromosomeMaterial offspring
 */
protected ChromosomeMaterial reproduce( Configuration config, Chromosome dominantChrom,
		Chromosome recessiveChrom ) {
	ChromosomeMaterial child = dominantChrom.cloneMaterial();
	child.setSecondaryParentId( recessiveChrom.getId() );

	Iterator iter = child.getAlleles().iterator();
	while ( iter.hasNext() ) {
		Allele allele = (Allele) iter.next();
		if ( allele instanceof ConnectionAllele ) {
			ConnectionAllele dominantConnectionAllele = (ConnectionAllele) allele;
			ConnectionAllele recessiveConnectionAllele = (ConnectionAllele) recessiveChrom
					.findMatchingGene( dominantConnectionAllele );
			if ( recessiveConnectionAllele != null ) {
				// TODO blending?
				if ( config.getRandomGenerator().nextBoolean() )
					dominantConnectionAllele.setWeight( recessiveConnectionAllele.getWeight() );
			}
		}
	}

	return child;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Removes, in ascending order of weight magnitude, those connections whose weight magnitude is
 * less than the maximum weight to be removed. Maximum number of connections that can be removed
 * is determined by mutation rate.
 * 
 * @param jgapConfig must be <code>NeatConfiguration</code>
 * @param target chromosome material to mutate
 * @param allelesToAdd <code>Set</code> contains <code>Allele</code> objects
 * @param allelesToRemove <code>Set</code> contains <code>Allele</code> objects
 * @see org.jgap.MutationOperator#mutate(org.jgap.Configuration, org.jgap.ChromosomeMaterial,
 * java.util.Set, java.util.Set)
 */
protected void mutate( Configuration jgapConfig, final ChromosomeMaterial target,
		Set allelesToAdd, Set allelesToRemove ) {
	if ( ( jgapConfig instanceof NeatConfiguration ) == false )
		throw new AnjiRequiredException( "com.anji.neat.NeatConfiguration" );
	NeatConfiguration config = (NeatConfiguration) jgapConfig;
	List allConns = NeatChromosomeUtility.getConnectionList( target.getAlleles() );

	if ( Strategy.SMALL.equals( strategy ) )
		mutateSmall( config, allConns, allelesToRemove );
	else if ( Strategy.ALL.equals( strategy ) )
		mutateAll( config, allConns, allelesToRemove );
	else if ( Strategy.SKEWED.equals( strategy ) )
		mutateSkewed( config, allConns, allelesToRemove );
	else
		throw new IllegalStateException( "invalid remove connection operator strategy: " + strategy );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Adds connections according to <a
 * href="http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf">NEAT </a> add connection
 * mutation.
 * 
 * @param jgapConfig
 * @param target chromosome material to mutate
 * @param allelesToAdd <code>Set</code> contains <code>Allele</code> objects
 * @param allelesToRemove <code>Set</code> contains <code>Allele</code> objects
 * @see org.jgap.MutationOperator#mutate(org.jgap.Configuration, org.jgap.ChromosomeMaterial,
 * java.util.Set, java.util.Set)
 */
protected void mutate( Configuration jgapConfig, final ChromosomeMaterial target,
		Set allelesToAdd, Set allelesToRemove ) {
	if ( ( jgapConfig instanceof NeatConfiguration ) == false )
		throw new AnjiRequiredException( "com.anji.neat.NeatConfiguration" );
	NeatConfiguration config = (NeatConfiguration) jgapConfig;

	// connection can mutate between any 2 neurons, excluding those neurons already removed
	List neuronList = NeatChromosomeUtility.getNeuronList( target.getAlleles() );
	SortedMap conns = NeatChromosomeUtility.getConnectionMap( target.getAlleles() );

	// Determine # neurons to add and iterate randomly through alleles ...
	int maxConnectionsToAdd = ( neuronList.size() * neuronList.size() ) - conns.size();
	int numConnectionsToAdd = numMutations( config.getRandomGenerator(), maxConnectionsToAdd );

	addConnections( numConnectionsToAdd, config, neuronList, conns, allelesToAdd );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Adds connections according to <a
 * href="http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf">NEAT </a> add node mutation.
 * @see org.jgap.MutationOperator#mutate(org.jgap.Configuration, org.jgap.ChromosomeMaterial,
 * java.util.Set, java.util.Set)
 */
protected void mutate( Configuration jgapConfig, final ChromosomeMaterial target,
		Set allelesToAdd, Set allelesToRemove ) {
	if ( ( jgapConfig instanceof NeatConfiguration ) == false )
		throw new AnjiRequiredException( "com.anji.neat.NeatConfiguration" );
	NeatConfiguration config = (NeatConfiguration) jgapConfig;

	Map neurons = NeatChromosomeUtility.getNeuronMap( target.getAlleles() );

	// neuron can be mutated on any connection
	List connList = NeatChromosomeUtility.getConnectionList( target.getAlleles() );
	Collections.shuffle( connList, config.getRandomGenerator() );

	int numConnections = numMutations( config.getRandomGenerator(), connList.size() );
	Iterator iter = connList.iterator();
	int count = 0;
	while ( iter.hasNext() && ( count++ < numConnections ) ) {
		ConnectionAllele oldConnectAllele = (ConnectionAllele) iter.next();
		addNeuronAtConnection( config, neurons, oldConnectAllele, allelesToAdd, allelesToRemove );
	}
}
 

import org.jgap.Configuration; //导入依赖的package包/类
public IChromosome apply (IChromosome firstMate, IChromosome secondMate, RandomGenerator generator, Configuration config) throws InvalidConfigurationException
{
	Gene[] rgGenes = new Gene[m_nElementPerOperand];
	for (int i = 0; i < m_nElementPerOperand; i++)
		rgGenes[i] = new IntegerGene (config, 0, 2 * m_nElementPerOperand - 1);
	
	int[] rgOpConfig = new int[m_mapSelectors.size ()];

	int nIdx = 0;
	for (int nID : m_listIDs)
	{
		List<Selector> list = m_mapSelectors.get (nID);
		rgOpConfig[nIdx] = generator.nextInt (list.get (0).getArgsCount ());
		for (Selector s : list)
			rgGenes[s.getIndex ()].setAllele (s.getResult (firstMate, secondMate, rgOpConfig[nIdx], m_nElementPerOperand));
		nIdx++;
	}
	
	List<Operand> listParent = new ArrayList<> (2);
	listParent.add ((Operand) firstMate.getApplicationData ());
	if (m_nOperandsCount >= 2)
		listParent.add ((Operand) secondMate.getApplicationData ());

	IChromosome c = new Chromosome (config, rgGenes);
	c.setApplicationData (new Operand (null, null, listParent, this, rgOpConfig));
	return c;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
public NaturalSelector getSelector(final Configuration config) throws InvalidConfigurationException {
	final BestChromosomesSelector selector = new BestChromosomesSelector(config,model.getValue() / 100.0);
	selector.setDoubletteChromosomesAllowed(false);
	//selector.setDoubletteChromosomesAllowed(doubletteCheckBox.isSelected());
	
	return selector;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
public IdentifiableLongGene(final String id, final Configuration a_config, final long lowerBound, final long upperBound) throws InvalidConfigurationException {
	super(a_config);
	Preconditions.checkNotNull(id);
	this.id = id;
	this.lowerBound = lowerBound;
	this.upperBound = upperBound;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
public NaturalSelector getSelector(final Configuration config) throws InvalidConfigurationException {
		final int size = (Integer) tournamentSizeModel.getValue();
		final double probability = selectionProbabilityModel.getValue() / 100.0;
		final TournamentSelector selector = new TournamentSelector(config,size,probability);
//		selector.setDoubletteChromosomesAllowed(doubletteCheckBox.isSelected());
		
		return selector;
	}
 

import org.jgap.Configuration; //导入依赖的package包/类
public EliteTournamentCrossoverer( Configuration aConfig, float elitismRate, int tournamentSize )
		throws InvalidConfigurationException {
	super( aConfig );
	m_chromosomes = new Vector<IChromosome>();
	m_needsSorting = false;
	m_fitnessValueComparator = new FitnessValueComparator();
	random = getConfiguration().getRandomGenerator();
	this.elitismRate = elitismRate;
	this.tournamentSize = tournamentSize;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Constructs a new IntegerGene with the given active configuration and the specified lower and
 * upper bounds for values represented by this Gene.
 * 
 * @param a_activeConfiguration The current active configuration.
 * @param a_lowerBounds The lowest value that this Gene may represent, inclusive.
 * @param a_upperBounds The highest value that this Gene may represent, inclusive.
 */
public IntegerAllele( Configuration a_activeConfiguration, int a_lowerBounds, int a_upperBounds ) {
	super( new Gene( ( a_activeConfiguration == null ) ? new Long( 0 ) : a_activeConfiguration
			.nextInnovationId() ) );
	m_activeConfiguration = a_activeConfiguration;
	m_lowerBounds = a_lowerBounds;
	m_upperBounds = a_upperBounds;
	calculateBoundsUnitsToIntegerUnitsRatio();
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Returns the <code>a_howManyToSelect</code> chromosomes with highest speciated fitness.
 * @param a_activeConfiguration
 * @param a_howManyToSelect
 * @return <code>List</code> contains <code>Chromosome</code> objects
 */
protected List select( Configuration a_activeConfiguration, int a_howManyToSelect ) {
	Collections.sort( chromosomes, 
		new ChromosomeFitnessComparator( false /* asc */, true /* speciated fitness*/ ) );
	List result = new ArrayList( a_howManyToSelect );
	Iterator it = chromosomes.iterator();
	while ( it.hasNext() && ( result.size() < a_howManyToSelect ) )
		result.add( it.next() );
	return result;
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * @param args
 * @throws Exception
 */
public static void main( String[] args ) throws Exception {
	DoublePoleBalanceFitnessFunction ff = new DoublePoleBalanceFitnessFunction();
	Properties props = new Properties();
	props.loadFromResource( args[ 0 ] );
	ff.init( props );
	Persistence db = (Persistence) props.newObjectProperty( Persistence.PERSISTENCE_CLASS_KEY );
	Configuration config = new DummyConfiguration();
	Chromosome chrom = db.loadChromosome( args[ 1 ], config );
	if ( chrom == null )
		throw new IllegalArgumentException( "no chromosome found: " + args[ 1 ] );
	ff.enableDisplay();
	ff.evaluate( chrom );
	logger.info( "Fitness = " + chrom.getFitnessValue() );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * @param config
 * @param xml
 * @return chromosome constructed from xml
 * @throws Exception
 */
public static Chromosome chromosomeFromXml( Configuration config, String xml ) throws Exception {
	ByteArrayInputStream in = new ByteArrayInputStream( xml.getBytes() );
	DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
	Document doc = builder.parse( in );
	return chromosomeFromXml( config, doc.getFirstChild() );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * @see org.jgap.ReproductionOperator#reproduce(org.jgap.Configuration, java.util.List, int,
 * java.util.List)
 */
public void reproduce( final Configuration config, final List parentChroms, int numOffspring,
		List offspring ) {
	for ( int i = 0; i < numOffspring; ++i ) {
		Chromosome c = (Chromosome) parentChroms.get( 0 );
		offspring.add( c.cloneMaterial() );
	}
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Load chromosome from persistence and activate it.
 * 
 * @param chromId persistence ID of chromosome
 * @return SortedMap contains key Integer index, value double[] response
 * @throws Exception
 * @see NeatActivator#activate(Activator)
 */
public SortedMap activate( String chromId ) throws Exception {
	Configuration config = new DummyConfiguration();
	Chromosome chrom = db.loadChromosome( chromId, config );

	Activator activator = activatorFactory.newActivator( chrom );
	db.store( activator );
	return activate( activator );
}
 

import org.jgap.Configuration; //导入依赖的package包/类
/**
 * Removes from <code>genesToAdd</code> and adds to <code>genesToRemove</code> all
 * connection genes that are modified.
 * 
 * @param jgapConfig The current active genetic configuration.
 * @param target chromosome material to mutate
 * @param genesToAdd <code>Set</code> contains <code>Gene</code> objects
 * @param genesToRemove <code>Set</code> contains <code>Gene</code> objects
 */
protected void mutate( Configuration jgapConfig, final ChromosomeMaterial target,
		Set genesToAdd, Set genesToRemove ) {
	if ( ( jgapConfig instanceof NeatConfiguration ) == false )
		throw new AnjiRequiredException( NeatConfiguration.class.toString() );
	NeatConfiguration config = (NeatConfiguration) jgapConfig;

	List conns = NeatChromosomeUtility.getConnectionList( target.getAlleles() );
	Collections.shuffle( conns, config.getRandomGenerator() );

	int numMutations = numMutations( config.getRandomGenerator(), conns.size() );
	Iterator iter = conns.iterator();
	int i = 0;
	while ( ( i++ < numMutations ) && iter.hasNext() ) {
		ConnectionAllele origAllele = (ConnectionAllele) iter.next();
		double nextWeight = origAllele.getWeight()
				+ ( config.getRandomGenerator().nextGaussian() * getStdDev() );
		if ( nextWeight > config.getMaxConnectionWeight() )
			nextWeight = config.getMaxConnectionWeight();
		else if ( nextWeight < config.getMinConnectionWeight() )
			nextWeight = config.getMinConnectionWeight();

		ConnectionAllele newAllele = (ConnectionAllele) origAllele.cloneAllele();
		newAllele.setWeight( nextWeight );

		genesToRemove.add( origAllele );
		genesToAdd.add( newAllele );
	}
}