source: java/ecj/cecj/app/numbers_game/MultiDimensionalNumbersGame.java @ 101

package cecj.app.numbers_game;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;

import cecj.interaction.InteractionResult;
import cecj.problems.SymmetricTestBasedProblem;
import cecj.statistics.ObjectiveFitnessCalculator;
import cecj.utils.Pair;

import ec.EvolutionState;
import ec.Individual;
import ec.util.Parameter;
import ec.vector.BitVectorIndividual;

public abstract class MultiDimensionalNumbersGame extends SymmetricTestBasedProblem implements
                ObjectiveFitnessCalculator {

        private static final String P_DIMENSIONS = "dimensions";
        private static final String P_DIM_SIZE = "dimension-size";

        private int numDimensions;
        private int dimensionSize;
        private int expectedGenomeLength;

        @Override
        public void setup(EvolutionState state, Parameter base) {
                super.setup(state, base);
                
                Parameter numDimensionsParam = base.push(P_DIMENSIONS);
                numDimensions = state.parameters.getInt(numDimensionsParam, null, 1);
                if (numDimensions <= 0) {
                        state.output
                                .fatal("Multi Dimensional Numbers Game dimensions must be specified and >= 0\n", numDimensionsParam);
                }

                Parameter dimensionSizeParam = base.push(P_DIM_SIZE);
                dimensionSize = state.parameters.getInt(dimensionSizeParam, null, 1);
                if (dimensionSize <= 0) {
                        state.output
                                .fatal("Multi Dimensional Numbers Game dimension size must be specified and >= 0\n", dimensionSizeParam);
                }

                expectedGenomeLength = numDimensions * dimensionSize;
        }

        @Override
        public Pair<? extends InteractionResult> test(EvolutionState state, Individual candidate,
                        Individual test) {
                if (!(candidate instanceof BitVectorIndividual) || !(test instanceof BitVectorIndividual)) {
                        state.output
                                .error("NumbersGame player's individual should be represented by bit vector\n");
                }

                BitVectorIndividual bitCandidate = (BitVectorIndividual) candidate;
                BitVectorIndividual bitTest = (BitVectorIndividual) test;

                if (bitCandidate.genomeLength() != bitTest.genomeLength()) {
                        state.output.error("NumbersGame players' bit vectors should be equal length\n");
                }

                if (bitCandidate.genomeLength() != expectedGenomeLength) {
                        state.output
                                .error("NumbersGame player's bit vector length must be equal to product of dimensions number and dimension size\n");
                }

                List<BigInteger> candidateVector = getIntegerVector(bitCandidate.genome);
                List<BigInteger> testVector = getIntegerVector(bitTest.genome);

                return compareDimensionsVectors(candidateVector, testVector);
        }

        /**
         * Returns objective fitness normalized to [0, 1] interval;
         */
        public float calculateObjectiveFitness(EvolutionState state, Individual ind) {
                if (!(ind instanceof BitVectorIndividual)) {
                        state.output.error("Competitor individuals should be represented by bit vectors\n");
                }
                BitVectorIndividual bitIndividual = (BitVectorIndividual) ind;

                BigDecimal dimensionMaxValue = new BigDecimal(2).pow(dimensionSize)
                        .subtract(BigDecimal.ONE);
                BigDecimal sumMaxValue = dimensionMaxValue.multiply(new BigDecimal(numDimensions));

                List<BigInteger> dimensionVector = getIntegerVector(bitIndividual.genome);
                BigDecimal sum = BigDecimal.ZERO;
                for (BigInteger dimension : dimensionVector) {
                        sum = sum.add(new BigDecimal(dimension));
                }

                return sum.divide(sumMaxValue, 10, RoundingMode.DOWN).floatValue();
        }

        private List<BigInteger> getIntegerVector(boolean[] genome) {
                List<BigInteger> result = new ArrayList<BigInteger>();
                BigInteger bigTwo = new BigDecimal(2).toBigInteger();

                for (int dim = 0; dim < numDimensions; dim++) {
                        BigInteger dimValue = BigInteger.ZERO;
                        for (int i = 0; i < dimensionSize; i++) {
                                dimValue = dimValue.multiply(bigTwo);
                                if (genome[(dim * dimensionSize) + i]) {
                                        dimValue = dimValue.add(BigInteger.ONE);
                                }
                        }
                        result.add(dimValue);
                }

                return result;
        }

        protected abstract Pair<? extends InteractionResult> compareDimensionsVectors(
                        List<BigInteger> candidateVector, List<BigInteger> testVector);
}