结构和数组

Question

I am currently looking at this:

some Genetic Algorithm

This is some adapted code:

struct Chromosome
{
    public bool[] genes;
    public int fitness;
}

I have never used structs in my evolutionary algorithms/genetic algorithms. Is it not a bit pointless to use arrays in structs - especially when I have to make deep copies? Is there any advantage of using structs in this scenario?

Thanks.

Answer 1

I don't see any problem with this... In GAs its all about validating the fitness of your candidates. the struct just capsulates all the information for your candidate. therefore the fitness is directly associated with your gene. It makes perfect sense to store it in the same class/struct.

If you do not store the fitness with your gene you have to map it somehow. This would be an unnecessary hassle. Or, if you do not want to store the fitness at all you have to recalculate it evertime you compare two candidates against each other. Would not be wise. especially if the fitness evaluation is rather complex (for example in a GA to evaluate the best parameters for a simulation).

I would use a class that implements the interface IComparable. Two candidates would than be compared by there fitness. Then you only need to sort your list of candidates and pick, for example, the best 10 candidates for the next generation (Always depends on the type of GA you are using).

about the bool array... I don't see any problem with this either. If this is how your gene is represented best... perfect :). The representation as a integer is also fine but in some cases it might make the x-over operation a bit complicated... always depends on the case...

Answer 2

The bool array will not get deep copied automatically in this case. So you're not really benefitting from structs because when you assign Chromosome to a new one, the reference in both would be to the same bool[ ]

Instead of using a bool[] you can just use a number: let's say int . A chromosome with genes = 3 represents gene: 0000 0000 0000 0000 0000 0011. A chromosome with genes = 42134 represents gene: 0000 0000 1010 0100 1001 0110. int is 32 bits which means that you can represent chromosomes with 2 ³² genes this way. You avoid having to worry about deep copying an array and this is faster and more efficient in terms of memory consumption too. Use Int64 if you need more genes.

Update: You're question is so cool btw. In case you have restrictions to the possible gene combinations in some segments, you need to construct the Int32 byte by byte according to the restrictions. To illustrate, I assumed an example for some restrictions on a Chromosome and randomly mutated a Chromosome but with respect to restraints.

        //The following creates a random chromosome with restrictions
        //to the genes as described in the following:

        //Let's say that the following pattern must be adhered to: 
        //byte 1 = xxxx xxxx (anything)
        //byte 2 = 1011 xxxx (restricted)
        //byte 3 = [0000 or 1111] xxxx (restricted)
        //byte 4 = 0000 1111 (fixed value)

        Random rnd = new Random();
        byte[] randomByte = new byte[1]; //xxxx xxxx xxxx xxxx

        byte restrictedByte2 = 
            (byte)(Math.Pow(2,7) * 1 + Math.Pow(2,6) * 0 + 
            Math.Pow(2,5) * 1 + Math.Pow(2,4) * 1 + 
            rnd.Next(0, 16)); //1011 xxxx

        //in byte 3, the first (most significant) for bits are restricted to either 0000 or 1111. 
        //That's either number 0 * 16 = 0 or number 15 * 16 = 240. I multiplied by 2^4 because it's shifted
        //4 bytes to the left.
        byte higherBits = (byte)(rnd.Next(0, 2/*upper bound exclusive*/) == 1?240:0);
        //random lower bits (xxxx).
        byte lowerBits = (byte)(Math.Pow(2,0) * rnd.Next(0, 2) + Math.Pow(2,1) * rnd.Next(0, 2) + 
            Math.Pow(2,2) * rnd.Next(0, 2) + Math.Pow(2,3) * rnd.Next(0, 2) + 
            rnd.Next(0, 16));

        byte restrictedByte3 = (byte)(lowerBits + higherBits);

        byte restrictedByte4 = 143; //constant

        //Create an Int32 from the four bytes.
        int randomMutation = BitConverter.ToInt32(
            new byte[] { randomByte[1], restrictedByte2, restrictedByte3, restrictedByte4 }, 0);

Answer 3

Typically, we use a struct to represent something that can be considered pretty primitive. According to MSDN , it should be a type that represents a single "value", 16 bytes or less in size, and so on.

The main thing to keep in mind with a struct is the value-type semantics, so passing this in and out of functions will create a copy. Cost wise this won't be too bad since what you are copying is 1 reference (to the array of bool) and 1 int, but it does create some interesting side effects if you try to modify the array reference in another method or from a copy.

Many people assume struct will always be more efficient than class , but this is not always the case and usually this micro-optimization is more dangerous than helpful because it introduces the side-effects of working with a value type.

As for the array of bool you can either create and set bits in an int or use the BitArray specialized class in the BCL.

So, the long and the short of it is, if this is legacy code and you want to keep the struct , it will work, but it can byte you if you expect it to act like a class does when passed/copied. However, looking at what it's holding, it doesn't meet the MSDN guidance for what struct is best suited for.