.get(1)));

		final EAExecutionContext<FitnessVector<Double>> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<FitnessVector<Double>> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<FitnessVector<Double>> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));

		final int depthIdx = 1;
		for (int i = 0; i < 15; i++) {
			final int depth = i;
			final Optional<Integer> optIdx = IntStream.range(0,
					evolutionResult.fitness()
							.size())
					.boxed()
					.filter((idx) -> evolutionResult.fitness()
							.get(idx)
							.get(depthIdx) == depth)
					.sorted((a, b) -> Double.compare(evolutionResult.fitness()
							.get(a)
							.get(0),
							evolutionResult.fitness()
									.get(b)
									.get(0)))
					.findFirst();

			optIdx.stream()
					.forEach((idx) -> {
						final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) evolutionResult
								.population()
								.get(idx)
								.getChromosome(0);

						logger.info("Best genotype for depth {} - score {} -> {}",
								depth,
								evolutionResult.fitness()
										.get(idx)
										.get(0),
								TreeNodeUtils.toStringTreeNode(treeChromosome.getRoot()));
					});
		}
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithMOO();

.termination(or(ofMaxGeneration(200), ofFitnessAtMost(20.0d))) // <3>
				.fitness(computeFitness);
		final EAConfiguration<Double> eaConfiguration = eaConfigurationBuilder.build();
		// end::ea_config[]

		final var eaExecutionContextBuilder = GPEAExecutionContexts.<Double>forGP(random);
		EAExecutionContexts.enrichForScalarFitness(eaExecutionContextBuilder);

		eaExecutionContextBuilder.populationSize(populationSize);
		eaExecutionContextBuilder.numberOfPartitions(Math.max(1,
				Runtime.getRuntime()
						.availableProcessors() - 1));

		eaExecutionContextBuilder.addEvolutionListeners(
				EvolutionListeners.ofLogTopN(logger, 5, Comparator.<Double>reverseOrder(), (genotype) -> {
					final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithConstantParsimonyPressure();

formatter.printHelp(SymbolicRegressionWithMOO.class.getSimpleName(), options);
		System.exit(-1);
	}

	@SuppressWarnings("unchecked")
	public void run(String csvFilename, int populationSize) {
		Validate.isTrue(StringUtils.isNotBlank(csvFilename));
		Validate.isTrue(populationSize > 0);

		final Random random = new Random();

		final Program program = SymbolicRegressionUtils.buildProgram(random);

		final Comparator<Genotype> deduplicator = (a, b) -> TreeNodeUtils.compare(a, b, 0);

		// tag::compute_fitness[]
		final Fitness<FitnessVector<Double>> computeFitness = (genoType) -> {
			final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genoType.getChromosome(0);
			final Double[][] inputs = new Double[100][1];
			for (int i = 0; i < 100; i++) {
				inputs[i][0] = (i - 50) * 1.2;
			}

			double mse = 0;
			for (final Double[] input : inputs) {

				final double x = input[0];
				final double expected = SymbolicRegressionUtils.evaluate(x);
				final Object result = ProgramUtils.execute(chromosome, input);

				if (Double.isFinite(expected)) {
					final Double resultDouble = (Double) result;
					if (Double.isFinite(resultDouble)) {
						mse += (expected - resultDouble) * (expected - resultDouble);
					} else {
						mse += 1_000_000_000;
					}
				}
			}

			return Double.isFinite(mse) ? new FitnessVector<Double>(mse / 100.0,
					(double) chromosome.getRoot()
							.getSize())
					: new FitnessVector<Double>(Double.MAX_VALUE, Double.MAX_VALUE);
		};
		// end::compute_fitness[]

		// tag::ea_config[]
		final var eaConfigurationBuilder = new EAConfiguration.Builder<FitnessVector<Double>>();
		eaConfigurationBuilder.chromosomeSpecs(ProgramTreeChromosomeSpec.of(program)) // <1>
				.parentSelectionPolicy(TournamentNSGA2Selection.ofFitnessVector(2, 3, deduplicator)) // <2>
				.replacementStrategy(Elitism.builder() // <3>

final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithConstantParsimonyPressure();

final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithDoubleTournament();

final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithProportionalTournament();

final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithSRT();

final var fChromosome = genotype.getChromosome(0, DoubleChromosome.class);
		final int[] clusters = new int[samples.length];
		final double[] bestProb = new double[samples.length];

		for (int c = 0; c < clusters.length; c++) {
			clusters[c] = 0;
			bestProb[c] = Double.MIN_VALUE;
		}

		double sumAlpha = 0.0f;
		int k = 0;
		while (k < fChromosome.getSize()) {
			sumAlpha += fChromosome.getAllele(k);
			k += distributionNumParameters;
		}

		int i = 0;
		int clusterIndex = 0;
		while (i < fChromosome.getSize()) {

			final double alpha = fChromosome.getAllele(i) / sumAlpha;
			final double[] mean = new double[] { fChromosome.getAllele(i + 1), fChromosome.getAllele(i + 2) };
			final double[][] covariance = new double[][] {
					{ fChromosome.getAllele(i + 3) - 15, fChromosome.getAllele(i + 4) - 15 },
					{ fChromosome.getAllele(i + 4) - 15, fChromosome.getAllele(i + 5) - 15 } };

			try {
				final var multivariateNormalDistribution = new MultivariateNormalDistribution(mean, covariance);

				for (int j = 0; j < samples.length; j++) {
					float likelyhood = (float) (alpha * multivariateNormalDistribution.density(samples[j]));

					if (clusters[j] < 0 || bestProb[j] < likelyhood) {
						bestProb[j] = likelyhood;
						clusters[j] = clusterIndex;
					}
				}
			} catch (NonPositiveDefiniteMatrixException | SingularMatrixException | MathUnsupportedOperationException e) {
			}

			i += distributionNumParameters;
			clusterIndex++;
		}

		return clusters;
	}

	public static int[] assignClustersFloatChromosome(final int distributionNumParameters, final double[][] samples,

formatter.printHelp(SymbolicRegressionWithDoubleTournament.class.getSimpleName(), options);
		System.exit(-1);
	}

	@SuppressWarnings("unchecked")
	public void run(String csvFilename, int populationSize) {
		Validate.isTrue(StringUtils.isNotBlank(csvFilename));
		Validate.isTrue(populationSize > 0);

		final Random random = new Random();

		final Program program = SymbolicRegressionUtils.buildProgram(random);

		// tag::compute_fitness[]
		final Double[][] inputs = new Double[100][1];
		for (int i = 0; i < 100; i++) {
			inputs[i][0] = (i - 50) * 1.2;
		}

		final Fitness<Double> computeFitness = (genoType) -> {
			final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genoType.getChromosome(0);

			double mse = 0;
			for (final Double[] input : inputs) {

				final double x = input[0];
				final double expected = SymbolicRegressionUtils.evaluate(x);
				final Object result = ProgramUtils.execute(chromosome, input);

				if (Double.isFinite(expected)) {
					final Double resultDouble = (Double) result;
					mse += Double.isFinite(resultDouble) ? (expected - resultDouble) * (expected - resultDouble)
							: 1_000_000_000;
				}
			}
			return Double.isFinite(mse) ? mse / 100.0d : Double.MAX_VALUE;
		};
		// end::compute_fitness[]

		// tag::double_tournament[]
		final Comparator<Individual<Double>> parsimonyComparator = (a, b) -> {
			final var treeChromosomeA = a.genotype()
					.getChromosome(0, TreeChromosome.class);
			final var treeChromosomeB = b.genotype()
					.getChromosome(0, TreeChromosome.class);

			return Integer.compare(treeChromosomeA.getSize(), treeChromosomeB.getSize());

formatter.printHelp(SymbolicRegressionWithConstantParsimonyPressure.class.getSimpleName(), options);
		System.exit(-1);
	}

	@SuppressWarnings("unchecked")
	public void run(String csvFilename, int populationSize) {
		Validate.isTrue(StringUtils.isNotBlank(csvFilename));
		Validate.isTrue(populationSize > 0);

		final Random random = new Random();

		final Program program = SymbolicRegressionUtils.buildProgram(random);

		// tag::compute_fitness[]
		final Fitness<Double> computeFitness = (genoType) -> {
			final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genoType.getChromosome(0);
			final Double[][] inputs = new Double[100][1];
			for (int i = 0; i < 100; i++) {
				inputs[i][0] = (i - 50) * 1.2;
			}

			double mse = 0;
			for (final Double[] input : inputs) {

				final double x = input[0];
				final double expected = SymbolicRegressionUtils.evaluate(x);
				final Object result = ProgramUtils.execute(chromosome, input);

				if (Double.isFinite(expected)) {
					final Double resultDouble = (Double) result;
					mse += Double.isFinite(resultDouble) ? (expected - resultDouble) * (expected - resultDouble)
							: 1_000_000_000;
				}
			}
			return Double.isFinite(mse) ? mse / 100.0 + 1.5 * chromosome.getSize() : Double.MAX_VALUE; // <1>

}
	}

	@Override
	public Genotype mutate(final long generation, final Genotype original) {
		Validate.isTrue(generation >= 0);
		Objects.requireNonNull(original);

		if (randomGenerator.nextDouble() < populationMutationProbability == false) {
			return original;
		}

		final Chromosome[] newChromosomes = new Chromosome[original.getSize()];
		final Chromosome[] chromosomes = original.getChromosomes();
		for (int chromosomeIndex = 0; chromosomeIndex < chromosomes.length; chromosomeIndex++) {
			final ChromosomeSpec chromosomeSpec = eaConfiguration.getChromosomeSpec(chromosomeIndex);
			final Chromosome chromosome = chromosomes[chromosomeIndex];

			if (chromosomeSpec instanceof ProgramTreeChromosomeSpec == false) {
				throw new IllegalArgumentException("This mutator does not support chromosome specs " + chromosomeSpec);
			}

			if (chromosome instanceof TreeChromosome<?> == false) {
				throw new IllegalArgumentException(
						"This mutator does not support chromosome of type " + chromosome.getClass()
								.getSimpleName());
			}

			final ProgramTreeChromosomeSpec programTreeChromosomeSpec = (ProgramTreeChromosomeSpec) chromosomeSpec;

			final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) chromosome;
			final int chromosomeSize = treeChromosome.getSize();

			if (chromosomeSize > 2) {
				final int cutPoint = randomGenerator.nextInt(chromosomeSize - 1) + 1;

				final TreeNode<Operation<?>> root = treeChromosome.getRoot();
				final TreeNode<Operation<?>> newRoot = duplicateAndReplaceNode(programTreeChromosomeSpec.program(),

this.randomGenerator = _randomGenerator;
	}

	protected Individual<T> randomIndividual(final List<Genotype> population, final List<T> fitnessScore) {
		Objects.requireNonNull(population);
		Objects.requireNonNull(fitnessScore);
		Validate.isTrue(fitnessScore.size() > 0);
		Validate.isTrue(population.size() == fitnessScore.size());

		final int candidateIndex = randomGenerator.nextInt(fitnessScore.size());
		return Individual.of(population.get(candidateIndex), fitnessScore.get(candidateIndex));

	}

	protected Individual<T> selectForFitness(final AbstractEAConfiguration<T> eaConfiguration,
			final Comparator<Individual<T>> fitnessComparator, final int numCandidates, final List<Genotype> population,
			final List<T> fitnessScore) {
		Objects.requireNonNull(population);
		Objects.requireNonNull(fitnessScore);
		Validate.isTrue(fitnessScore.isEmpty() == false);

		return IntStream.range(0, numCandidates)
				.boxed()
				.map(i -> randomIndividual(population, fitnessScore))
				.max((a, b) -> fitnessComparator.compare(a, b))
				.get();
	}

	protected Individual<T> selectForRefinement(final Comparator<Individual<T>> refinementComparator,

public final static Fitness<Double> computeFitness(final int numDataPoints, final double[][] data,
			double[][] distances, final int numClusters) {
		Validate.notNull(data);
		Validate.notNull(distances);
		Validate.isTrue(numDataPoints > 0);
		Validate.isTrue(numDataPoints == data.length);
		Validate.isTrue(numDataPoints == distances.length);
		Validate.isTrue(numClusters > 0);

		return (genoType) -> {

			final double[][] clusters = PhenotypeUtils.toPhenotype(genoType);

			final int[] closestClusterIndex = assignDataToClusters(data, distances, clusters);

			final Map<Integer, Set<Integer>> clusterToMembers = new HashMap<>();

			for (int i = 0; i < numDataPoints; i++) {
				final var members = clusterToMembers.computeIfAbsent(closestClusterIndex[i], k -> new HashSet<>());
				members.add(i);
			}

			double sum_si = 0.0;
			for (int i = 0; i < numDataPoints; i++) {
				sum_si += computeSilhouetteScore(data, distances, numClusters, clusterToMembers, closestClusterIndex, i);
			}

public static void persistClusters(final float[] x, final float[] y, final int[] cluster, final String filename)
			throws IOException {
		Validate.isTrue(x.length == y.length);
		Validate.isTrue(x.length == cluster.length);
		logger.info("Saving clusters to CSV: {}", filename);

		final CSVPrinter csvPrinter;
		try {
			csvPrinter = CSVFormat.DEFAULT.withAutoFlush(true)
					.withHeader(new String[] { "cluster", "x", "y" })
					.print(Path.of(filename), StandardCharsets.UTF_8);
		} catch (IOException e) {
			logger.error("Could not open {}", filename, e);
			throw new RuntimeException("Could not open file " + filename, e);
		}

		for (int i = 0; i < cluster.length; i++) {
			try {
				csvPrinter.printRecord(cluster[i], x[i], y[i]);
			} catch (IOException e) {
				throw new RuntimeException("Could not write data", e);
			}
		}
		csvPrinter.close(true);
	}

	// TODO fix duplication
	public static void persistClusters(final double[] x, final double[] y, final int[] cluster, final String filename)

final float alpha = fChromosome.getAllele(i) / sumAlpha;
				if (alpha > 0.0001) {
					final double[] mean = new double[] { fChromosome.getAllele(i + 1), fChromosome.getAllele(i + 2) };
					final double[][] covariances = new double[][] {
							{ fChromosome.getAllele(i + 3) - 15, fChromosome.getAllele(i + 4) - 15 },
							{ fChromosome.getAllele(i + 4) - 15, fChromosome.getAllele(i + 5) - 15 } };

					try {
						final var multivariateNormalDistribution = new MultivariateNormalDistribution(mean, covariances);

						for (int j = 0; j < samples.length; j++) {
							final var density = multivariateNormalDistribution.density(samples[j]);
							likelyhoods[j] += alpha * density;
						}
					} catch (NonPositiveDefiniteMatrixException | MathUnsupportedOperationException
							| SingularMatrixException e) {
					}
				}
				i += distributionNumParameters;
			}

}

	public static void main(String[] args) throws IOException {

		/**
		 * Parse CLI
		 */

		final CommandLineParser parser = new DefaultParser();

		final Options options = new Options();
		options.addOption(PARAM_DEST_CSV, LONG_PARAM_DEST_CSV, true, "destination csv file");

		options.addOption(PARAM_POPULATION_SIZE, LONG_PARAM_POPULATION_SIZE, true, "Population size");

		String csvFilename = DEFAULT_DEST_CSV;
		int populationSize = DEFAULT_POPULATION_SIZE;
		try {
			final CommandLine line = parser.parse(options, args);

			if (line.hasOption(PARAM_DEST_CSV)) {
				csvFilename = line.getOptionValue(PARAM_DEST_CSV);
			}

			if (line.hasOption(PARAM_POPULATION_SIZE)) {
				populationSize = Integer.parseInt(line.getOptionValue(PARAM_POPULATION_SIZE));
			}

		} catch (ParseException exp) {
			cliError(options, "Unexpected exception:" + exp.getMessage());
		}

		logger.info("Population size: {}", populationSize);

		logger.info("CSV output located at {}", csvFilename);
		FileUtils.forceMkdirParent(new File(csvFilename));

		final var symbolicRegression = new SymbolicRegressionWithConstantParsimonyPressure();

.anyMatch(fv -> fv.get(0) <= 0.000001 && fv.get(1) <= 20))) // <4>
				.fitness(computeFitness);
		final EAConfiguration<FitnessVector<Double>> eaConfiguration = eaConfigurationBuilder.build();
		// end::ea_config[]

		// tag::eae_moo[]
		final var eaExecutionContextBuilder = GPEAExecutionContexts.<FitnessVector<Double>>forGP(random);
		// end::eae_moo[]
		eaExecutionContextBuilder.populationSize(populationSize);
		eaExecutionContextBuilder.numberOfPartitions(Math.max(1,
				Runtime.getRuntime()
						.availableProcessors() - 3));

		eaExecutionContextBuilder.addEvolutionListeners(
				EvolutionListeners.ofLogTopN(logger,
						5,
						Comparator.<FitnessVector<Double>, Double>comparing(fv -> fv.get(0))
								.reversed(),
						(genotype) -> TreeNodeUtils.toStringTreeNode(genotype, 0)),
				SymbolicRegressionUtils.csvLogger(csvFilename,
						evolutionStep -> evolutionStep.fitness()
								.get(0),
						evolutionStep -> evolutionStep.fitness()
								.get(1)));

}

	@Override
	public List<Chromosome> combine(final AbstractEAConfiguration<T> eaConfiguration, final Chromosome chromosome1,
			final T firstParentFitness, final Chromosome chromosome2, final T secondParentFitness) {
		Validate.notNull(chromosome1);
		Validate.notNull(chromosome2);
		Validate.isInstanceOf(IntChromosome.class, chromosome1);
		Validate.isInstanceOf(IntChromosome.class, chromosome2);
		Validate.isTrue(chromosome1.getNumAlleles() == chromosome2.getNumAlleles());

		final int alleleSplit = randomGenerator.nextInt(chromosome1.getNumAlleles());

		final IntChromosome intChromosome1 = (IntChromosome) chromosome1;
		final IntChromosome intChromosome2 = (IntChromosome) chromosome2;

		final int numAlleles = chromosome1.getNumAlleles();
		final int[] firstChildValues = new int[numAlleles];
		final int[] secondChildValues = new int[numAlleles];

		for (int i = 0; i < numAlleles; i++) {

final Random random = new Random();

		final Program program = SymbolicRegressionUtils.buildProgram(random);

		// tag::compute_fitness[]
		final Fitness<Double> computeFitness = (genoType) -> {
			final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genoType.getChromosome(0);
			final Double[][] inputs = new Double[100][1];
			for (int i = 0; i < 100; i++) {
				inputs[i][0] = (i - 50) * 1.2;
			}

			double mse = 0;
			for (final Double[] input : inputs) {

				final double x = input[0];
				final double expected = SymbolicRegressionUtils.evaluate(x);
				final Object result = ProgramUtils.execute(chromosome, input);

				if (Double.isFinite(expected)) {

final Comparator<Genotype> individualDeduplicator = nsga2Selection.deduplicate()
					.get();
			final Set<Genotype> seenGenotype = new TreeSet<>(individualDeduplicator);

			for (int i = 0; i < population.size(); i++) {
				final Genotype genotype = population.get(i);
				final T fitness = fitnessScore.get(i);

				if (seenGenotype.add(genotype)) {
					individuals.add(genotype, fitness);
				}
			}

		} else {
			for (int i = 0; i < population.size(); i++) {
				final Genotype genotype = population.get(i);
				final T fitness = fitnessScore.get(i);

				individuals.add(genotype, fitness);
			}
		}

		logger.debug("Selecting {} individuals from a population of {}", numIndividuals, individuals.size());

		final int numberObjectives = nsga2Selection.numberObjectives();

SymbolicRegressionUtils.csvLoggerDouble(csvFilename,
						evolutionStep -> evolutionStep.fitness(),
						evolutionStep -> (double) evolutionStep.individual()
								.getChromosome(0, TreeChromosome.class)
								.getSize()));

		final EAExecutionContext<Double> eaExecutionContext = eaExecutionContextBuilder.build();
		final EASystem<Double> eaSystem = EASystemFactory.from(eaConfiguration, eaExecutionContext);

		final EvolutionResult<Double> evolutionResult = eaSystem.evolve();
		final Genotype bestGenotype = evolutionResult.bestGenotype();
		final TreeChromosome<Operation<?>> bestChromosome = (TreeChromosome<Operation<?>>) bestGenotype.getChromosome(0);
		logger.info("Best genotype: {}", bestChromosome.getRoot());
		logger.info("Best genotype - pretty print: {}", TreeNodeUtils.toStringTreeNode(bestChromosome.getRoot()));
	}

	public static void main(String[] args) throws IOException {

this.offspringSelector = _offspringSelector;
	}

	@Override
	public Population<T> select(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
			final int numIndividuals, final List<Genotype> population, final List<T> populationScores,
			final List<Genotype> offsprings, final List<T> offspringScores) {
		Objects.requireNonNull(eaConfiguration);
		Validate.isTrue(generation >= 0);
		Validate.isTrue(numIndividuals > 0);
		Objects.requireNonNull(population);
		Objects.requireNonNull(populationScores);
		Validate.isTrue(population.size() == populationScores.size());
		Objects.requireNonNull(offsprings);
		Objects.requireNonNull(offspringScores);
		Validate.isTrue(offsprings.size() == offspringScores.size());

		final Comparator<T> populationComparator = eaConfiguration.fitnessComparator();

final Chromosome[] newChromosomes = new Chromosome[original.getSize()];
		final Chromosome[] chromosomes = original.getChromosomes();
		for (int chromosomeIndex = 0; chromosomeIndex < chromosomes.length; chromosomeIndex++) {
			final ChromosomeSpec chromosomeSpec = eaConfiguration.getChromosomeSpec(chromosomeIndex);
			final Chromosome chromosome = chromosomes[chromosomeIndex];

			if (chromosomeSpec instanceof ProgramTreeChromosomeSpec == false) {
				throw new IllegalArgumentException("This mutator does not support chromosome specs " + chromosomeSpec);
			}

			if (chromosome instanceof TreeChromosome<?> == false) {
				throw new IllegalArgumentException(
						"This mutator does not support chromosome of type " + chromosome.getClass()
								.getSimpleName());
			}

			final ProgramTreeChromosomeSpec programTreeChromosomeSpec = (ProgramTreeChromosomeSpec) chromosomeSpec;

			final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) chromosome;
			final int chromosomeSize = treeChromosome.getSize();

final Chromosome[] newChromosomes = new Chromosome[original.getSize()];
		final Chromosome[] chromosomes = original.getChromosomes();
		for (int chromosomeIndex = 0; chromosomeIndex < chromosomes.length; chromosomeIndex++) {
			final ChromosomeSpec chromosomeSpec = eaConfiguration.getChromosomeSpec(chromosomeIndex);
			final Chromosome chromosome = chromosomes[chromosomeIndex];

			if (chromosomeSpec instanceof ProgramTreeChromosomeSpec == false) {
				throw new IllegalArgumentException("This mutator does not support chromosome specs " + chromosomeSpec);
			}

			if (chromosome instanceof TreeChromosome<?> == false) {
				throw new IllegalArgumentException(
						"This mutator does not support chromosome of type " + chromosome.getClass()
								.getSimpleName());
			}

			final ProgramTreeChromosomeSpec programTreeChromosomeSpec = (ProgramTreeChromosomeSpec) chromosomeSpec;

			final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) chromosome;
			final int chromosomeSize = treeChromosome.getSize();

}

	@Override
	public Population<T> select(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
			final int numIndividuals, final List<Genotype> population, final List<T> populationScores,
			final List<Genotype> offsprings, final List<T> offspringScores) {
		Objects.requireNonNull(eaConfiguration);
		Validate.isTrue(generation >= 0);
		Validate.isTrue(numIndividuals > 0);
		Objects.requireNonNull(population);
		Objects.requireNonNull(populationScores);
		Validate.isTrue(population.size() == populationScores.size());
		Objects.requireNonNull(offsprings);
		Objects.requireNonNull(offspringScores);
		Validate.isTrue(offsprings.size() == offspringScores.size());

		final Comparator<T> populationComparator = eaConfiguration.fitnessComparator();

}

	@Override
	public Population<T> select(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
			final int numIndividuals, final List<Genotype> population, final List<T> populationScores,
			final List<Genotype> offsprings, final List<T> offspringScores) {
		Objects.requireNonNull(eaConfiguration);
		Validate.isTrue(generation >= 0);
		Validate.isTrue(numIndividuals > 0);
		Objects.requireNonNull(population);
		Objects.requireNonNull(populationScores);
		Validate.isTrue(population.size() == populationScores.size());
		Objects.requireNonNull(offsprings);
		Objects.requireNonNull(offspringScores);
		Validate.isTrue(offsprings.size() == offspringScores.size());

Class[] acceptedTypes = currentNode.acceptedTypes();

		for (int i = 0; i < acceptedTypes.length; i++) {
			final Class acceptedType = acceptedTypes[i];
			final TreeNode<Operation<?>> operation = generate(program, acceptedType, maxDepth, 1);

			currentTreeNode.addChild(operation);
		}

		return currentTreeNode;
	}

	@Override
	public <T, U> TreeNode<Operation<T>> generate(final Program program, final int maxDepth, final Class<U> rootType) {
		Validate.notNull(program);
		Validate.notNull(rootType);
		Validate.isTrue(maxDepth > 0);

		return generate(program, rootType, maxDepth, 0);
	}
}

if (isOperation(t, Functions.NAME_SUB) == false) {
			return false;
		}

		if (hasChildOperation(t, 0, Terminals.TYPE_INPUT) == false) {
			return false;
		}

		if (hasChildOperation(t, 1, Terminals.TYPE_INPUT) == false) {
			return false;
		}

		final InputOperation<?> firstInput = (InputOperation<Double>) t.getChild(0)
				.getData();

		final InputOperation<?> secondInput = (InputOperation<Double>) t.getChild(1)
				.getData();

		return firstInput.index() == secondInput.index();
	}, (program, t) -> {

		final InputSpec inputSpec = program.inputSpec();

		final OperationFactory coefficientFactory = OperationFactories

logger.trace("Mutating genotype {}", originalGenotype);

		final Chromosome[] newChromosomes = new Chromosome[originalGenotype.getSize()];
		final Chromosome[] chromosomes = originalGenotype.getChromosomes();
		for (int chromosomeIndex = 0; chromosomeIndex < chromosomes.length; chromosomeIndex++) {
			final ChromosomeSpec chromosomeSpec = eaConfiguration.getChromosomeSpec(chromosomeIndex);
			final Chromosome chromosome = chromosomes[chromosomeIndex];

			if (chromosomeSpec instanceof ProgramTreeChromosomeSpec == false) {
				throw new IllegalArgumentException("This mutator does not support chromosome specs " + chromosomeSpec);
			}

			if (chromosome instanceof TreeChromosome<?> == false) {
				throw new IllegalArgumentException(
						"This mutator does not support chromosome of type " + chromosome.getClass()
								.getSimpleName());
			}

			final ProgramTreeChromosomeSpec programTreeChromosomeSpec = (ProgramTreeChromosomeSpec) chromosomeSpec;

			final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) chromosome;

public static void persistDataPoints(final double[][] data, final String filename) throws IOException {
		Validate.notBlank(filename);

		logger.info("Saving data to CSV: {}", filename);

		final int numDataPoints = data.length;

		final CSVPrinter csvPrinter;
		try {
			csvPrinter = CSVFormat.DEFAULT.withAutoFlush(true)
					.withHeader(new String[] { "cluster", "x", "y" })
					.print(Path.of(filename), StandardCharsets.UTF_8);
		} catch (IOException e) {
			logger.error("Could not open {}", filename, e);
			throw new RuntimeException("Could not open file " + filename, e);
		}

		for (int i = 0; i < numDataPoints; i++) {
			try {
				csvPrinter.printRecord((int) data[i][2], data[i][0], data[i][1]);

OperationFactory currentNode = depth < maxDepth - 1 ? programHelper.pickRandomFunction(program, acceptedType)
				: programHelper.pickRandomTerminal(program, acceptedType);

		final Operation<T> currentOperation = currentNode.build(program.inputSpec());
		final TreeNode<Operation<T>> currentTreeNode = new TreeNode<>(currentOperation);

		final Class[] acceptedTypes = currentNode.acceptedTypes();

		for (int i = 0; i < acceptedTypes.length; i++) {
			final Class childAcceptedType = acceptedTypes[i];
			final TreeNode<Operation<T>> operation = generate(program, childAcceptedType, maxDepth, depth + 1);

			currentTreeNode.addChild(operation);
		}

		return currentTreeNode;
	}

	public FullProgramGenerator(final ProgramHelper _programHelper) {

Validate.isInstanceOf(ProportionalTournament.class, _selectionPolicy);
		Objects.requireNonNull(_randomGenerator);

		this.selectionPolicy = _selectionPolicy;
		this.randomGenerator = _randomGenerator;
	}

	@Override
	public Population<T> select(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
			final int numIndividuals, final List<Genotype> population, final List<T> fitnessScore) {
		Objects.requireNonNull(eaConfiguration);
		Objects.requireNonNull(population);
		Objects.requireNonNull(fitnessScore);
		Validate.isTrue(generation >= 0);
		Validate.isTrue(numIndividuals > 0);
		Validate.isTrue(population.size() == fitnessScore.size());

		@SuppressWarnings("unchecked")
		final ProportionalTournament<T> proportionalTournament = (ProportionalTournament<T>) selectionPolicy;

}

	@Override
	public Population<T> select(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
			final int numIndividuals, final List<Genotype> population, final List<T> fitnessScore) {
		Objects.requireNonNull(eaConfiguration);
		Objects.requireNonNull(population);
		Objects.requireNonNull(fitnessScore);
		Validate.isTrue(generation >= 0);
		Validate.isTrue(numIndividuals > 0);
		Validate.isTrue(population.size() == fitnessScore.size());

		logger.debug("Incoming population size is {}", population.size());

		final Population<T> individuals = new Population<>();
		if (nsga2Selection.deduplicate()

final Chromosome[] chromosomes = originalGenotype.getChromosomes();
		for (int chromosomeIndex = 0; chromosomeIndex < chromosomes.length; chromosomeIndex++) {
			final ChromosomeSpec chromosomeSpec = eaConfiguration.getChromosomeSpec(chromosomeIndex);
			final Chromosome chromosome = chromosomes[chromosomeIndex];

			if (chromosomeSpec instanceof ProgramTreeChromosomeSpec == false) {
				throw new IllegalArgumentException("This mutator does not support chromosome specs " + chromosomeSpec);
			}

			if (chromosome instanceof TreeChromosome<?> == false) {
				throw new IllegalArgumentException(
						"This mutator does not support chromosome of type " + chromosome.getClass()
								.getSimpleName());
			}

			final ProgramTreeChromosomeSpec programTreeChromosomeSpec = (ProgramTreeChromosomeSpec) chromosomeSpec;

			final TreeChromosome<Operation<?>> treeChromosome = (TreeChromosome<Operation<?>>) chromosome;
			final int chromosomeSize = treeChromosome.getSize();

final double[] dataLinear = new double[data.length * numColumns];
		for (int i = 0; i < data.length; i++) {
			if (data[i].length != numColumns) {
				throw new IllegalArgumentException(
						String.format("Got %d columns for index %d. Should have been %d", data[i].length, i, numColumns));
			}

			final int baseIndex = i * numColumns;
			for (int j = 0; j < numColumns; j++) {
				dataLinear[baseIndex + j] = data[i][j];
			}
		}

		return of(dataLinear, readOnly);
	}

	/**
	 * Expect an evenly shaped data
	 * 
	 * @param data
	 * @param readOnly
	 * @return
	 */
	public static StaticDataLoader ofLinearize(final float[][] data, final boolean readOnly) {

.build())
				.combinationPolicy(ProgramRandomCombine.build())
				.mutationPolicies(MultiMutations
						.of(ProgramRandomMutate.of(0.15 * 3), ProgramRandomPrune.of(0.15 * 3), NodeReplacement.of(0.15 * 3)),
						ProgramApplyRules.of(SimplificationRules.SIMPLIFY_RULES))
				.optimization(Optimization.MINIMIZE)
				.termination(Terminations.or(Terminations.<FitnessVector<Double>>ofMaxGeneration(200),
						(eaConfiguration, generation, population, fitness) -> fitness.stream()
								.anyMatch(fv -> fv.get(0) <= 0.000001 && fv.get(1) <= 20))) // <4>

final public static Rule ADD_TWO_COEFFCIENTS = ImmutableRule.of((t) -> isOperation(t, Functions.NAME_ADD)
			&& hasChildOperation(t, 0, Terminals.TYPE_COEFFICIENT) && hasChildOperation(t, 1, Terminals.TYPE_COEFFICIENT),
			(program, t) -> {

				final InputSpec inputSpec = program.inputSpec();

				final CoefficientOperation<Double> firstCoefficient = getChildAs(t, 0, CoefficientOperation.class);
				final Double firstValue = firstCoefficient.value();

				final CoefficientOperation<Double> secondCoefficient = getChildAs(t, 1, CoefficientOperation.class);
				final Double secondValue = secondCoefficient.value();

				final OperationFactory coefficientFactory = OperationFactories
						.ofCoefficient(Terminals.TYPE_COEFFICIENT, Double.class, firstValue + secondValue);

final int numberObjectives, final Comparator<Genotype> deduplicate) {

		final var builder = new Builder<FitnessVector<U>>();

		builder.objectiveComparator((m) -> (a, b) -> Double.compare(a.get(m)
				.doubleValue(),
				b.get(m)
						.doubleValue()))
				.distance((a, b, m) -> Math.abs(b.get(m)
						.doubleValue()
						- a.get(m)
								.doubleValue()))
				.numberObjectives(numberObjectives)
				.deduplicate(Optional.ofNullable(deduplicate));

Validate.isInstanceOf(DoubleChromosome.class, chromosome2);
		Validate.isTrue(chromosome1.getNumAlleles() == chromosome2.getNumAlleles());

		Validate.isTrue(multiPointArithmeticPolicy.numCrossovers() < chromosome1.getNumAlleles());
		Validate.isTrue(multiPointArithmeticPolicy.numCrossovers() < chromosome2.getNumAlleles());

		final int numCrossovers = multiPointArithmeticPolicy.numCrossovers();
		final double alpha = multiPointArithmeticPolicy.alpha();

		final int[] alleleSplits = randomGenerator.ints(0, chromosome1.getNumAlleles())
				.distinct()
				.limit(numCrossovers)
				.sorted()
				.toArray();

		final DoubleChromosome doubleChromosome1 = (DoubleChromosome) chromosome1;

if (useChromosome1) {
				firstChildValues[i] = (int) (alpha * firstAllele + (1 - alpha) * secondAllele);
				secondChildValues[i] = (int) ((1 - alpha) * firstAllele + alpha * secondAllele);
			} else {
				firstChildValues[i] = (int) ((1 - alpha) * firstAllele + alpha * secondAllele);
				secondChildValues[i] = (int) (alpha * firstAllele + (1 - alpha) * secondAllele);
			}
		}

		return List.of(
				new IntChromosome(numAlleles, intChromosome1.getMinValue(), intChromosome2.getMaxValue(), firstChildValues),

final double[] dataLinear = new double[data.length * numColumns];
		for (int i = 0; i < data.length; i++) {
			if (data[i].length != numColumns) {
				throw new IllegalArgumentException(
						String.format("Got %d columns for index %d. Should have been %d", data[i].length, i, numColumns));
			}

			final int baseIndex = i * numColumns;
			for (int j = 0; j < numColumns; j++) {
				dataLinear[baseIndex + j] = data[i][j];
			}
		}

		return of(dataLinear, readOnly);
	}

	/**
	 * Expect an evenly shaped data
	 * 
	 * @param data
	 * @param readOnly
	 * @return
	 */
	public static StaticDataLoader ofLinearize(final float[][] data, final boolean readOnly) {

.limit(numCrossovers)
				.sorted()
				.toArray();

		final DoubleChromosome doubleChromosome1 = (DoubleChromosome) chromosome1;
		final DoubleChromosome doubleChromosome2 = (DoubleChromosome) chromosome2;

		final int numAlleles = chromosome1.getNumAlleles();
		final double[] firstChildValues = new double[numAlleles];
		final double[] secondChildValues = new double[numAlleles];

		boolean useChromosome1 = true;
		int splitIndex = 0;
		for (int i = 0; i < doubleChromosome1.getNumAlleles(); i++) {

			if (splitIndex < alleleSplits.length && i == alleleSplits[splitIndex]) {
				splitIndex++;
				useChromosome1 = !useChromosome1;
			}

.limit(numCrossovers)
				.sorted()
				.toArray();

		final FloatChromosome floatChromosome1 = (FloatChromosome) chromosome1;
		final FloatChromosome floatChromosome2 = (FloatChromosome) chromosome2;

		final int numAlleles = chromosome1.getNumAlleles();
		final float[] firstChildValues = new float[numAlleles];
		final float[] secondChildValues = new float[numAlleles];

		boolean useChromosome1 = true;
		int splitIndex = 0;
		for (int i = 0; i < floatChromosome1.getNumAlleles(); i++) {

			if (splitIndex < alleleSplits.length && i == alleleSplits[splitIndex]) {
				splitIndex++;
				useChromosome1 = !useChromosome1;
			}

.limit(numCrossovers)
				.sorted()
				.toArray();

		final IntChromosome intChromosome1 = (IntChromosome) chromosome1;
		final IntChromosome intChromosome2 = (IntChromosome) chromosome2;

		final int numAlleles = chromosome1.getNumAlleles();
		final int[] firstChildValues = new int[numAlleles];
		final int[] secondChildValues = new int[numAlleles];

		boolean useChromosome1 = true;
		int splitIndex = 0;
		for (int i = 0; i < intChromosome1.getNumAlleles(); i++) {

			if (splitIndex < alleleSplits.length && i == alleleSplits[splitIndex]) {
				splitIndex++;
				useChromosome1 = !useChromosome1;
			}

final double[] dataLinear = new double[data.length * numColumns];
		for (int i = 0; i < data.length; i++) {
			if (data[i].length != numColumns) {
				throw new IllegalArgumentException(
						String.format("Got %d columns for index %d. Should have been %d", data[i].length, i, numColumns));
			}

			final int baseIndex = i * numColumns;
			for (int j = 0; j < numColumns; j++) {
				dataLinear[baseIndex + j] = data[i][j];
			}
		}

		return of(dataLinear, readOnly);
	}

	/**
	 * Expect an evenly shaped data
	 * 
	 * @param data
	 * @param readOnly
	 * @return
	 */
	public static StaticDataLoader ofLinearize(final float[][] data, final boolean readOnly) {

.termination(or(ofMaxGeneration(200), ofFitnessAtMost(20.0d))) // <3>
				.fitness(computeFitness);
		final EAConfiguration<Double> eaConfiguration = eaConfigurationBuilder.build();
		// end::ea_config[]

		final var eaExecutionContextBuilder = GPEAExecutionContexts.<Double>forGP(random);
		EAExecutionContexts.enrichForScalarFitness(eaExecutionContextBuilder);

		eaExecutionContextBuilder.populationSize(populationSize);
		eaExecutionContextBuilder.numberOfPartitions(Math.max(1,
				Runtime.getRuntime()
						.availableProcessors() - 1));

		eaExecutionContextBuilder.addEvolutionListeners(
				EvolutionListeners.ofLogTopN(logger, 5, Comparator.<Double>reverseOrder(), (genotype) -> {
					final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);

eaExecutionContextBuilder.populationSize(populationSize);
		eaExecutionContextBuilder.numberOfPartitions(Math.max(1,
				Runtime.getRuntime()
						.availableProcessors() - 1));

		eaExecutionContextBuilder.addEvolutionListeners(
				EvolutionListeners.ofLogTopN(logger, 5, Comparator.<Double>reverseOrder(), (genotype) -> {
					final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,

eaExecutionContextBuilder.populationSize(populationSize);
		eaExecutionContextBuilder.numberOfPartitions(Math.max(1,
				Runtime.getRuntime()
						.availableProcessors() - 1));

		eaExecutionContextBuilder.addEvolutionListeners(
				EvolutionListeners.ofLogTopN(logger, 5, Comparator.<Double>reverseOrder(), (genotype) -> {
					final TreeChromosome<Operation<?>> chromosome = (TreeChromosome<Operation<?>>) genotype.getChromosome(0);
					final TreeNode<Operation<?>> root = chromosome.getRoot();

					return TreeNodeUtils.toStringTreeNode(root);
				}),
				SymbolicRegressionUtils.csvLoggerDouble(csvFilename,

public abstract class NSGA2Selection<T extends Comparable<T>> implements SelectionPolicy {

	/**
	 * Number of objectives
	 * 
	 * @return
	 */
	@Value.Parameter
	public abstract int numberObjectives();

	/**
	 * Override the dominance operator.
	 * <p>If not specified, it assumes the default comparator conforms to the Pareto dominance relation
	 * 
	 * @return
	 */
	@Value.Default
	public Comparator<T> dominance() {
		return (a, b) -> a.compareTo(b);
	}

	/**
	 * Comparator used for deduplication of solution prior to processing
	 * <p>If not specified, it defaults to not do any deduplication
	 * 
	 * @return
	 */
	@Value.Default
	public Optional<Comparator<Genotype>> deduplicate() {
		return Optional.empty();
	}

	/**
	 * Sort T based on the objective passed as a parameter
	 * 
	 * @return
	 */
	@Value.Parameter
	public abstract Function<Integer, Comparator<T>> objectiveComparator();

	/**
	 * Define how to compute distances between fitness scores along their objectives
	 * 
	 * @return Distance computation method
	 */
	@Value.Parameter
	public abstract ObjectiveDistance<T> distance();

if (useChromosome1) {
				firstChildValues[i] = doubleChromosome1.getAllele(i);
				secondChildValues[i] = doubleChromosome2.getAllele(i);
			} else {
				firstChildValues[i] = doubleChromosome2.getAllele(i);
				secondChildValues[i] = doubleChromosome1.getAllele(i);
			}
		}

		/**
		 * TODO Should the min/max values be extended based on the lowest/highest values?
		 */
		final double minValue = doubleChromosome1.getMinValue();
		final double maxValue = doubleChromosome2.getMaxValue();

		return List.of(new DoubleChromosome(numAlleles, minValue, maxValue, firstChildValues),
				new DoubleChromosome(numAlleles, minValue, maxValue, secondChildValues));
	}
}

if (useChromosome1) {
				firstChildValues[i] = floatChromosome1.getAllele(i);
				secondChildValues[i] = floatChromosome2.getAllele(i);
			} else {
				firstChildValues[i] = floatChromosome2.getAllele(i);
				secondChildValues[i] = floatChromosome1.getAllele(i);
			}
		}

		/**
		 * TODO Should the min/max values be extended based on the lowest/highest values?
		 */
		final float minValue = floatChromosome1.getMinValue();
		final float maxValue = floatChromosome2.getMaxValue();

		return List.of(new FloatChromosome(numAlleles, minValue, maxValue, firstChildValues),
				new FloatChromosome(numAlleles, minValue, maxValue, secondChildValues));
	}
}

final OperationFactory currentNode = programHelper.pickRandomFunction(program);

		final Operation currentOperation = currentNode.build(program.inputSpec());
		final TreeNode<Operation<?>> currentTreeNode = new TreeNode<>(currentOperation);

		Class[] acceptedTypes = currentNode.acceptedTypes();

		for (int i = 0; i < acceptedTypes.length; i++) {
			final Class acceptedType = acceptedTypes[i];
			final TreeNode<Operation<?>> operation = generate(program, acceptedType, maxDepth, 1);

			currentTreeNode.addChild(operation);
		}

		return currentTreeNode;
	}

	@Override
	public <T, U> TreeNode<Operation<T>> generate(final Program program, final int maxDepth, final Class<U> rootType) {