I have a set of `Individual`s at first:

```
class Individual {
    double characteristics[];
    abstract double CalculateValue();
    ...
}

```

Each individual has a set of characteristics. Those characteristics will be implemented by the user of my library through inheritance:

```
class MyIndividualABC : Individual {
    public MyIndividualABC() {
        characteristics = new double[2];
        characteristics[0] = 123;
        characteristics[1] = 456;
    }

    public override double CalculateValue() { 
        return characteristics[0] / characteristics[1]; //for example
    }
}

```

I will then take them and give to each one of them a score (based on their value). I will call this doing an iteration.

```
class EvaluatedIndividual {
    double value;
    double score; //score was calculated based on value
}

```

From iteration2 and beyond, I will be always having at hand objects of type `EvaluatedIndividual`. But the first time, I will have to lead with objects of type `Individual`.

I wouldn't like to have to treat the first iteration in a different way than the other ones. How should I approach this?

*An analogy would be to have a class of students. Before the first exam, you just know their names, and from the 1st exam on you will have both their names and the average of the scores of their exams up to that moment.*

I have devised 3 different ways to handle this:

1. I will have a `Start()` method on my program and then an `Iteration()`. The `Start()` takes `Individual[]` while the `Iteration()` takes `EvaluatedIndividual[]`. Hacky, but will work wonders. Will use this if nothing better comes up.
2. `EvaluatedIndividual` inherits from `Individual`. This looks clean, but I am not too sure about it because I'd like `Individual` to be an interface and my idea would be to allow the client of my library/framework to inherit from it and define a set of methods/fields on `Individual` as he wants (`Individual` could have multiple values that'd be taken into consideration for calculating `value`, for instance) . If I follow this approach, I'd have to make him also implement a class from `EvaluatedIndividual`.
3. Individual is formed by value and a both `evaluation` and `wasEvaluated`. At first wasEvaluated was false, so any attempt to gather `value` throws up an Exception. I don't particulary like this, but I am not sure why.

How'd you approach this? This is probably a pretty common pattern, but I am afraid I don't know any GoF pattern that matches this scenario :(

Thanks