Simple application of genetic algorithm-solving equations

The first genetic algorithm tells the basic idea of genetic algorithm, this blog uses genetic algorithm to solve the equation.

The following are specific:

Solution of Equation-x^3+7*x+13=0 in [3,4] interval, solution accurate to 0.001, crossover probability 0.7

Mutation probability 0.01, iteration number 100, character encoding length 10 (binary encoding)

Let's start with a simple analysis:

1. Encoding and decoding

The topic requires the use of binary encoding method to achieve, since it has been encoded, the natural need to decode, given the 10

Bit binary encoding representation of the interval range is 0~1023, the topic of the interval is [3,4] it is natural to think of the 10-bit binary

The 0 representation in the encoding is that the 3,1023 in [3,4] represents 4 in [3,4], so each binary corresponds to the

The decimal is ((10-bit binary corresponding decimal number/1023) +3), this is decoded in the interval [3,4] in the specific value.

2. Fitness function

The fitness function taken here is the reciprocal of the absolute value of the equation, i.e. f=1/(|-x^3+7*x+13|)

3. Select operator

Determine the selection ratio, using the roulette algorithm.

        /// <summary>        ///Simulation Roulette Selection Algorithm///ideas: 1. The sum of the degree of adaptability; 2. Calculate the proportion of each individual's fitness (except the first one, the others are superimposed); ///3. A random number is generated in the 0~1, and the interval of the random number is the individual to be selected/// </summary>        /// <returns>Select a good individual</returns>        Staticlist<int> RWS (list<Double>list) {List<int>Select=Newlist<int>(); List<Double> P =Newlist<Double>(); Doublesum = list. Sum ()/*The sum of the degree of adaptability*/, temp =0/*Temp Variable*/; foreach(varIteminchlist) {Temp+ = (item/sum);//OverlayP.add (temp);//probability            }            intI, J;  for(i =0; i < P.count; i++) {Temp= Rd. Nextdouble ();//random number of 0~1                 for(j =0; J < P.count; J + +)                {                    if(J = =0&& Temp < p[0])                    {                        Select. ADD (0); }                    Else if(Temp < P[J] && temp >= p[j-1])                    {                        Select.                    Add (j); }                }            }                       return Select; }    

View Code

4. Mating operator

Randomly produces mating bits, exchanging part of the genes of two chromosomes.

        /// <summary>        ///the change of the individual in the cross process (substitution of characters)/// </summary>        /// <param name= "dic" >two individuals involved in the crossover</param>        /// <param name= "Geti1" >individual 1</param>        /// <param name= "Geti2" >Individual 2</param>        /// <returns></returns>        Staticlist<string> Crossover_replace (dictionary<int,int> DiC,stringGETI1,stringGeti2) {            intIndexDoublep; List<string> Tmp_group =Newlist<string> ();//storing the individual after crossing            foreach(varIteminchdic) {p=Rd.                Nextdouble (); if(P <= crossover_probability)//probability is less than 0.7 to cross{Index= Rd. Next (0,8); Geti1= Group[item. Key];//two individuals to crossGeti2 =Group[item.                    Value]; //implementation of the crossoverTmp_group. ADD (geti1. Insert (geti1. Length, Geti2. Substring (index)). Remove (Index, Str_length-index)); Tmp_group. ADD (Geti2. Insert (Geti2. Length, Geti1. Substring (index)). Remove (index, Str_length-index)); }                Else{Tmp_group. ADD (Group[item.                    Key]); Tmp_group. ADD (Group[item.                Value]); }            }            returnTmp_group; }

View Code

5. Mutation operator

Transform the value of the chromosome gene, that is, the 0-1,1-0 transformation.

        /// <summary>        ///individual changes in the mutation process (0->1,1->0)///idea: 1. Convert individual codes into characters; 2. Generate a 0~1 random number for each character to determine if a mutation operation is needed///3. To mutate, the 0->1,1->0 will be/// </summary>        /// <param name= "str" >individual (binary code)</param>        /// <param name= "Result" >the result after the mutation</param>        /// <param name= "probability" >mutation Probability</param>        /// <returns></returns>        Static stringMutation_replace (stringStrstringResultDoubleprobability) {            Char[] Chrarray =Str.            ToCharArray ();  for(inti =0; I < Chrarray.count (); i++)            {                //less than probability, substitution character                if(Rd. Nextdouble () <=probability) {                    if(Chrarray[i] = ='0') {Chrarray[i]='1'; }                    Else if(Chrarray[i] = ='1') {Chrarray[i]='0'; }                }            }            //stitching characters into a string            foreach(CharChinchChrarray) {Result+=ch; }            returnresult; }

View Code

One of the methods, implementation is not unique, time is more daring, also did not make a certain optimization, just for the sake of familiarity with the algorithm and written.

Hope to help beginners, but also welcome you to propose changes.

The full code can be downloaded here

Https://github.com/hwqdt/Catcher.Equation

Simple application of genetic algorithm-solving equations