C++ DNA类代码示例

 DNA* initSultan5(int& m, int& n)
 {
   SmartArrayPtr<double> *diag, *sdiag, *kap;
   m = 5;
   n = 6;
  
   DNA* dna = new DNA(n, n - m);
   diag = dna->getDiag();
   sdiag = dna->getSDiag();
   kap = dna->getKap();

   diag->alloc(m);
   sdiag->alloc(m);
   kap->alloc(m);
   
   for(int i = 0; i < 5; i ++) {
     (*diag)[i] = 0.;
     (*sdiag)[i] = 1.;
   }
   (*kap)[0] = 24.;
   (*kap)[1] = 27.;
   (*kap)[2] = 33.;      
   (*kap)[3] = 37.;      
   (*kap)[4] = 24.;

   return dna;
 }

// Making the next generation
void Population::reproduction()
{
    // Refill the population with children from the mating pool
    for( int i = 0; i < mPopulation.size(); i++ )
	{
		// Sping the wheel of fortune to pick two parents
		int m = randInt( mMatingPool.size() );
		int d = randInt( mMatingPool.size() );
		// Pick two parents
		RocketRef mom = mMatingPool[m];
		RocketRef dad = mMatingPool[d];
		// Get their genes
		DNA *momgenes = mom->getDNA();
		DNA *dadgenes = dad->getDNA();
		// Mate their genes
		DNA *child = momgenes->crossover( dadgenes );
		// Mutate their genes
		child->mutate( mMutationRate );
		// Fill the new population with the new child
		Vec2f location = Vec2f( getWindowWidth() / 2.0, getWindowHeight() + 20.0 );
		
		mPopulation[i].reset(); // get rid of the old rocket
		mPopulation[i] = std::make_shared<Rocket>( location, child, mTarget );
    }
    mGenerations++;
}

//--------------------------------------------------------------
void ofApp::draw()
{
	if (!foundSolution)
	{
		for (int i = 0; i < ArrayCount(population); i++)
		{
			population[i].Fitness();
		}

		vector<DNA> matingPool = vector<DNA>();
		for (int i = 0; i < ArrayCount(population); i++)
		{
			int n = int(population[i].fitness * ArrayCount(population));
			for (int k = 0; k < n; k++)
			{
				matingPool.push_back(population[i]);
			}
		}

		for (int i = 0; i < ArrayCount(population); i++)
		{
			int a = int(ofRandom(0, matingPool.size()));
			int b = int(ofRandom(0, matingPool.size()));

			DNA parentA = matingPool[a];
			DNA parentB = matingPool[b];

			DNA child = parentA.crossover(parentB);
			child.mutate();

			population[i] = child;
		}
	}

	ofClear(ofColor::white);

	ofSetColor(ofColor::black);
	for (int i = 0; i < ArrayCount(population); i++)
	{
		//string str = population[i].genes;
		population[i].genes[ArrayCount(population[i].genes)] = '\0';

		if (population[i].genes == target)
		{
			foundSolution = true;
			ofNoFill();
			ofSetLineWidth(6);
			ofSetCurveResolution(200);
			ofCircle(ofPoint((int(i / POPULATION_PER_COLUMN) * Y_SPACING) + 100, 
								((i % POPULATION_PER_COLUMN) * X_SPACING) + BUFFER_SPACING), 120);
		}
		

		myFont.drawString(population[i].genes, 
							(int(i / POPULATION_PER_COLUMN) * Y_SPACING) + BUFFER_SPACING, 
							((i % POPULATION_PER_COLUMN) * X_SPACING) + BUFFER_SPACING);

	}

}

RNA DnaConfig::add_DNA_CrossTalk(DNA& dnaTotal)
{
	DNA dnaCrossTalk;
	RNA rnaCrossTalk;

    //Cross Talk
    if (m_chkCrossTalk)
    {
        dnaCrossTalk.AddCell(CrsTlk , Pn4, m_CTFE);
        dnaCrossTalk.AddCell(CrsTlkD, Pn4, m_CTFE);
        dnaCrossTalk.AddCell(CrsTlkW, Pn4, m_CTFE);
    }

	if (dnaCrossTalk.Size()) 
	{
		Ts->Trans(dnaCrossTalk, rnaCrossTalk);
		rnaCrossTalk.SortQuackMsr();
	}

	showRNA(rnaCrossTalk);
	dnaTotal += dnaCrossTalk;

	return rnaCrossTalk;
	
}

GenePool::GenePool(char* filename, int nseed, int nrlock, int simtype, int runs, int smult, int lmult)
{
   seed = nseed;
   reactionlock = nrlock;
   //for (int i = 0;i < 30;i++)
   //{
      DNA a;a.load(filename);
      dnavect.push_back(a);
      
      
      int addfit = 0;
      for (int aja = 0;aja < runs;aja++)
      {
         AIPlayer ai;
         KeyState ks;
      //Random ran;
         GameSpace gs(1, 0, 800, 0, 600, (seed-1) + aja, true, "test.lua", "shinku.lua");
         while (gs.updateGameState(ks) == 1)
	      {
            ks = ai.update(&gs, gs.thePlayer, dnavect[0], ks);
         }
      addfit += gs.thePlayer->getScore()*smult;
      addfit += gs.thePlayer->getLives()*lmult;
      }
      fitness.push_back(addfit / runs);
   
   return;
}

DNA Chromosome::getDNAObj() const
{
	DNA ret;
	list<DNA>::const_iterator iter = strands.cbegin();
	while (iter != strands.cend())
	{
		ret.setDNAInParts(iter->getDNA());
		iter++;
	}
	return ret;
}

DNA DNA::crossover(DNA partner){
    DNA child = DNA();
    // Picking a random “midpoint” in the genes array
    int midpoint = ofRandom(genes.size());
    for (int i = 0; i < genes.size(); i++) {
      // Before midpoint copy genes from one parent, after midpoint copy genes from the other parent
      if (i>midpoint) child.addGene(genes[i]);
      else child.addGene(partner.genes[i]);
    }
    //Return the new child DNA
    return child;
}

void DNA::DelCell(const DNA& compData)
{
    if (compData.Size())//裡面這些不要修改，影響再次量測的資料擺放
    {
        std::vector<Nucleotide>::const_iterator dnaItor = 0, compItor;
        std::vector<Nucleotide>::iterator rmBeginItor(End());

        for (compItor = compData.Begin(); compItor != compData.End(); ++compItor)
                rmBeginItor = std::remove(Begin(), rmBeginItor, *compItor);
        
        nChain.erase(rmBeginItor, End());
    }
}

void Population::reproduce() {
  for (int i = 0; i < popSize; i++) {
    int a = ofRandom(matingPool.size());
    int b = ofRandom(matingPool.size());
    DNA partnerA = matingPool[a];
    DNA partnerB = matingPool[b];
    //Step 3a: Crossover
    DNA child = partnerA.crossover(partnerB);
    //Step 3b: Mutation
    child.mutate(mutationRate);
    //Note that we are overwriting the population with the new children. When draw() loops, we will perform all the same steps with the new population of children.
    population[i] = child;
  }
}

//-----------------------------------------------------------------
// Crossover
DNA DNA::crossover(DNA partner) {
    // A new child
    DNA child;
    child.setup(geneSize);
    //int midpoint = int(ofRandom(genes.size())); // Pick a midpoint (NO RESPECT FOR GENE INTEGRITY)
    int midpoint = int(ofRandom(geneSize)); // Pick a midpoint (RESPECTING GENE INTEGRITY)

    // Half from one, half from the other
    for (int i = 0; i < genes.size(); i++) {
        if (i > midpoint) child.genes[i] = genes[i];
        else              child.genes[i] = partner.genes[i];
    }
    return child;

}

// Output the DNA
void Parser::print(std::ostream& iStream, const DNA& iDNA) {
    for (unsigned int i = 0; i < iDNA.genes(); i++) {
        // Extract the gene
        unsigned char* tGene;
        unsigned int tSize;
        iDNA.extract_gene(i, tGene, tSize);

        // Print the block
        std::cout << "* Human-readable version of block " << i << std::endl;
        print_block(iStream, tGene, tSize);

        // Free the block
        free(tGene);
    }
}

af::array Synthesizer::Impl::decodeAsArray(const DNA& dna)
{
    af::array result = af::constant(0, resultSize(), f32);
    unsigned dnaBeginIndex = 0;
    unsigned resultBeginIndex = 0;
    for (unsigned ruleIndex = 0; ruleIndex < rules.size(); ruleIndex++) {
        auto rule = rules[ruleIndex];

        unsigned ruleDnaSize = rule->dnaSize();
        unsigned ruleResultSize = rule->resultSize();
        unsigned dnaEndIndex = dnaBeginIndex + ruleDnaSize - 1;
        unsigned resultEndIndex = resultBeginIndex + ruleResultSize - 1;

        rule->decode(make_tuple(
            af::array(dna.array()(af::seq(dnaBeginIndex, dnaEndIndex))),
            std::ref(result),
            af::seq(resultBeginIndex, resultEndIndex),
            std::ref(states[ruleIndex])));

        dnaBeginIndex += ruleDnaSize;
        resultBeginIndex += ruleResultSize;
    }

    result.eval();
    return result;
}

PermutationTest& PermutationTest::permute (const char* filename, const int niter, Random &ran) {
	if (dna == 0) {
		dna = new DNA;
	}
	dna->readFASTA (filename);
	return permute (dna, niter, ran);
}

// Evaluate DNA
void Parser::evaluate(const DNA& iDNA) {
    // Reset the quotum
    mInstructionCounter = 0;

    // Evaluate all blocks
    for (unsigned int i = 0; i < iDNA.genes(); i++) {
        // Extract the blocks
        unsigned char* tGene;
        unsigned int tSize;
        iDNA.extract_gene(i, tGene, tSize);

        // Evaluate the block
        evaluate_block(tGene, tSize);

        // Free the block
        free(tGene);
    }
}

RNA DnaConfig::add_DNA_Gamma(DNA& dnaTotal)
{
	DNA dnaGamma;
	RNA rnaGamma;
	//Gamma
    if (m_chkWGamma || m_chkDGamma)        
                        dnaGamma.AddCell(White, PnGamma, m_WGammaBegin, m_WGamma_End, m_WGamma_Avg );  
    if (m_chkRGamma)    dnaGamma.AddCell(Red  , PnGamma, m_RGammaBegin, m_RGamma_End, m_RGamma_Avg );
    if (m_chkGGamma)    dnaGamma.AddCell(Green, PnGamma, m_GGammaBegin, m_GGamma_End, m_GGamma_Avg );
    if (m_chkBGamma)    dnaGamma.AddCell(Blue , PnGamma, m_BGammaBegin, m_BGamma_End, m_BGamma_Avg );

	if (dnaGamma.Size()) 
	{
		Ts->Trans(dnaGamma, rnaGamma);
		rnaGamma.SortOrigMsr();
	}
	dnaTotal += dnaGamma;

	return rnaGamma;
}