Terminations.java

package net.bmahe.genetics4j.core.termination;

import java.time.Duration;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import org.apache.commons.lang3.Validate;

import net.bmahe.genetics4j.core.Genotype;
import net.bmahe.genetics4j.core.spec.AbstractEAConfiguration;

/**
 * Utility class providing factory methods for creating common termination conditions in evolutionary algorithms.
 * 
 * <p>Terminations provides a comprehensive set of pre-built termination criteria that can be used individually or
 * combined to create complex stopping conditions for evolutionary algorithms. Each method returns a {@link Termination}
 * instance that encapsulates the specific logic for determining when evolution should stop.
 * 
 * <p>Available termination criteria include:
 * <ul>
 * <li><strong>Generation-based</strong>: Stop after a maximum number of generations</li>
 * <li><strong>Time-based</strong>: Stop after a specified duration has elapsed</li>
 * <li><strong>Fitness-based</strong>: Stop when fitness reaches certain thresholds</li>
 * <li><strong>Convergence-based</strong>: Stop when fitness stops improving for a period</li>
 * <li><strong>Logical combinations</strong>: Combine multiple criteria with AND/OR logic</li>
 * </ul>
 * 
 * <p>Termination criteria can be combined to create sophisticated stopping conditions:
 * 
 * <pre>{@code
 * // Stop after 100 generations OR when fitness reaches 0.95 OR after 5 minutes
 * Termination<Double> complexTermination = Terminations.or(
 * 		Terminations.ofMaxGeneration(100),
 * 			Terminations.ofFitnessAtLeast(0.95),
 * 			Terminations.ofMaxTime(Duration.ofMinutes(5)));
 * 
 * // Stop only when BOTH conditions are met: good fitness AND stable evolution
 * Termination<Double> conservativeTermination = Terminations
 * 		.and(Terminations.ofFitnessAtLeast(0.9), Terminations.ofStableFitness(20));
 * 
 * // Simple generation limit for quick experiments
 * Termination<Double> simpleTermination = Terminations.ofMaxGeneration(50);
 * }</pre>
 * 
 * <p>Common usage patterns:
 * <ul>
 * <li><strong>Development and testing</strong>: Use generation limits for quick experimentation</li>
 * <li><strong>Production systems</strong>: Combine time limits with fitness criteria for reliability</li>
 * <li><strong>Research applications</strong>: Use convergence detection to study algorithm behavior</li>
 * <li><strong>Resource-constrained environments</strong>: Use time-based limits for predictable execution</li>
 * </ul>
 * 
 * <p>Design considerations:
 * <ul>
 * <li><strong>Performance</strong>: Termination checks are called frequently; implementations are optimized</li>
 * <li><strong>Thread safety</strong>: Some termination criteria maintain internal state safely</li>
 * <li><strong>Flexibility</strong>: All criteria can be combined using logical operators</li>
 * <li><strong>Reliability</strong>: Include fallback termination criteria to prevent infinite loops</li>
 * </ul>
 * 
 * @see Termination
 * @see net.bmahe.genetics4j.core.EASystem
 * @see net.bmahe.genetics4j.core.spec.EAExecutionContext
 */
public class Terminations {

	/**
	 * Creates a termination condition that stops evolution after a specified number of generations.
	 * 
	 * <p>This is the most common termination criterion, providing a simple upper bound on the number of evolutionary
	 * cycles. The algorithm will terminate when the generation counter reaches or exceeds the specified maximum.
	 * 
	 * @param <T>           the type of fitness values in the evolutionary algorithm
	 * @param maxGeneration the maximum number of generations to run (must be positive)
	 * @return a termination condition that stops after the specified number of generations
	 * @throws IllegalArgumentException if maxGeneration is not positive
	 */
	public static <T extends Comparable<T>> Termination<T> ofMaxGeneration(final long maxGeneration) {
		Validate.isTrue(maxGeneration > 0);

		return new Termination<T>() {

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				Validate.isTrue(generation >= 0);

				return generation >= maxGeneration;
			}
		};
	}

	/**
	 * Creates a termination condition that stops evolution after a specified time duration.
	 * 
	 * <p>This time-based termination is useful for ensuring predictable execution times, especially in production
	 * environments or when computational resources are limited. The timer starts on the first evaluation and stops when
	 * the elapsed time exceeds the specified duration.
	 * 
	 * @param <T>      the type of fitness values in the evolutionary algorithm
	 * @param duration the maximum time to run the algorithm
	 * @return a termination condition that stops after the specified duration
	 * @throws IllegalArgumentException if duration is null
	 */
	public static <T extends Comparable<T>> Termination<T> ofMaxTime(final Duration duration) {
		Objects.requireNonNull(duration);

		return new Termination<T>() {

			private final long durationNanos = duration.toNanos();
			private Long startTime = null;

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				Validate.isTrue(generation >= 0);

				final long nowNanos = System.nanoTime();

				if (startTime == null) {
					startTime = nowNanos;
				}

				return (nowNanos - startTime) >= durationNanos;
			}
		};
	}

	/**
	 * Creates a termination condition that requires ALL specified conditions to be met.
	 * 
	 * <p>This logical AND operation creates a conservative termination strategy where evolution continues until every
	 * provided termination criterion is satisfied. Useful for ensuring multiple quality conditions are met before
	 * stopping.
	 * 
	 * @param <T>          the type of fitness values in the evolutionary algorithm
	 * @param terminations the termination conditions that must all be satisfied
	 * @return a termination condition that stops only when all conditions are met
	 * @throws IllegalArgumentException if terminations is null or empty
	 */
	@SafeVarargs
	public static <T extends Comparable<T>> Termination<T> and(final Termination<T>... terminations) {
		Objects.requireNonNull(terminations);
		Validate.isTrue(terminations.length > 0);

		return new Termination<T>() {

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				return Arrays.stream(terminations)
						.allMatch((termination) -> termination.isDone(eaConfiguration, generation, population, fitness));
			}

		};
	}

	/**
	 * Creates a termination condition that stops when ANY of the specified conditions is met.
	 * 
	 * <p>This logical OR operation creates a flexible termination strategy where evolution stops as soon as any one of
	 * the provided criteria is satisfied. Commonly used to provide multiple stopping conditions like time limits,
	 * generation limits, or fitness thresholds.
	 * 
	 * @param <T>          the type of fitness values in the evolutionary algorithm
	 * @param terminations the termination conditions, any of which can trigger stopping
	 * @return a termination condition that stops when any condition is met
	 * @throws IllegalArgumentException if terminations is null or empty
	 */
	@SafeVarargs
	public static <T extends Comparable<T>> Termination<T> or(final Termination<T>... terminations) {
		Objects.requireNonNull(terminations);
		Validate.isTrue(terminations.length > 0);

		return new Termination<T>() {

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				return Arrays.stream(terminations)
						.anyMatch((termination) -> termination.isDone(eaConfiguration, generation, population, fitness));
			}

		};
	}

	/**
	 * Creates a termination condition that stops when any individual reaches a minimum fitness threshold.
	 * 
	 * <p>This fitness-based termination is useful for maximization problems where you want to stop as soon as a solution
	 * of acceptable quality is found. The condition is satisfied when any individual in the population has a fitness
	 * value greater than or equal to the threshold.
	 * 
	 * @param <T>       the type of fitness values in the evolutionary algorithm
	 * @param threshold the minimum fitness value required to trigger termination
	 * @return a termination condition that stops when fitness reaches the threshold
	 * @throws IllegalArgumentException if threshold is null
	 */
	public static <T extends Comparable<T>> Termination<T> ofFitnessAtLeast(final T threshold) {
		Objects.requireNonNull(threshold);
		return new Termination<T>() {

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				Validate.isTrue(generation >= 0);

				return fitness.stream().anyMatch((fitnessValue) -> threshold.compareTo(fitnessValue) <= 0);
			}
		};
	}

	/**
	 * Creates a termination condition that stops when any individual reaches a maximum fitness threshold.
	 * 
	 * <p>This fitness-based termination is useful for minimization problems where you want to stop as soon as a solution
	 * of acceptable quality is found. The condition is satisfied when any individual in the population has a fitness
	 * value less than or equal to the threshold.
	 * 
	 * @param <T>       the type of fitness values in the evolutionary algorithm
	 * @param threshold the maximum fitness value required to trigger termination
	 * @return a termination condition that stops when fitness reaches the threshold
	 * @throws IllegalArgumentException if threshold is null
	 */
	public static <T extends Comparable<T>> Termination<T> ofFitnessAtMost(final T threshold) {
		Objects.requireNonNull(threshold);
		return new Termination<T>() {

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				Validate.isTrue(generation >= 0);

				return fitness.stream().anyMatch((fitnessValue) -> threshold.compareTo(fitnessValue) >= 0);
			}
		};
	}

	/**
	 * Creates a termination condition that stops when fitness stops improving for a specified number of generations.
	 * 
	 * <p>This convergence-based termination detects when the evolutionary algorithm has reached a stable state where
	 * further evolution is unlikely to yield significant improvements. It tracks the best fitness value and stops
	 * evolution if no improvement is observed for the specified number of consecutive generations.
	 * 
	 * <p>This termination criterion is particularly useful for:
	 * <ul>
	 * <li>Preventing unnecessary computation when the algorithm has converged</li>
	 * <li>Automatically adapting to problem difficulty</li>
	 * <li>Research applications studying convergence behavior</li>
	 * </ul>
	 * 
	 * @param <T>                    the type of fitness values in the evolutionary algorithm
	 * @param stableGenerationsCount the number of generations without improvement required to trigger termination
	 * @return a termination condition that stops when fitness plateaus
	 * @throws IllegalArgumentException if stableGenerationsCount is not positive
	 */
	public static <T extends Comparable<T>> Termination<T> ofStableFitness(final int stableGenerationsCount) {
		Validate.isTrue(stableGenerationsCount > 0);

		return new Termination<T>() {

			private long lastImprovedGeneration = -1;
			private T lastBestFitness = null;

			@Override
			public boolean isDone(final AbstractEAConfiguration<T> eaConfiguration, final long generation,
					final List<Genotype> population, final List<T> fitness) {
				Validate.isTrue(generation >= 0);

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

				final Optional<T> bestFitnessOpt = fitness.stream().max(fitnessComparator);

				if (lastImprovedGeneration < 0
						|| bestFitnessOpt.map(bestFitness -> fitnessComparator.compare(bestFitness, lastBestFitness) > 0)
								.orElse(false)) {
					lastImprovedGeneration = generation;
					lastBestFitness = bestFitnessOpt.get();
				}

				if (generation - lastImprovedGeneration > stableGenerationsCount) {
					return true;
				}
				return false;
			}
		};
	}
}


































Active mutators

CONDITIONALS_BOUNDARY
CONSTRUCTOR_CALLS
EMPTY_RETURNS
EXPERIMENTAL_ARGUMENT_PROPAGATION
EXPERIMENTAL_BIG_DECIMAL
EXPERIMENTAL_BIG_INTEGER
EXPERIMENTAL_MEMBER_VARIABLE
EXPERIMENTAL_NAKED_RECEIVER
EXPERIMENTAL_REMOVE_SWITCH_MUTATOR_[0-99]
EXPERIMENTAL_SWITCH
FALSE_RETURNS
INCREMENTS
INLINE_CONSTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NON_VOID_METHOD_CALLS
NULL_RETURNS
PRIMITIVE_RETURNS
REMOVE_CONDITIONALS_EQUAL_ELSE
REMOVE_CONDITIONALS_EQUAL_IF
REMOVE_CONDITIONALS_ORDER_ELSE
REMOVE_CONDITIONALS_ORDER_IF
REMOVE_INCREMENTS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:logicalAndRequiresAllConditions()] (1 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofStableFitnessNoImprovement()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofStableFitnessWithImprovement()] (3 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofFitnessAtLeastStopsWhenThresholdMet()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:logicalOrStopsWhenAnyConditionMet()] (1 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofFitnessAtMostStopsWhenThresholdMet()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofMaxTimeStopsAfterDuration()] (11 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofMaxGeneration()] (0 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testEvolveWithIntChromosome()] (8 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testEvolveWithPostEvaluationProcessor()] (15 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testEvolveWithBitChromosome()] (20 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:andRequiresAtLeastOneTermination()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofMaxGenerationInvalid()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofStableFitnessInvalid()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:maxTimeRequiresDuration()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofFitnessAtLeastRequiresThreshold()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:orRequiresAtLeastOneTermination()] (0 ms)
net.bmahe.genetics4j.core.termination.TerminationsTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.termination.TerminationsTest]/[method:ofFitnessAtMostRequiresThreshold()] (0 ms)
net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest]/[method:randomIsRequired()] (0 ms)
net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest]/[method:randomIsRequired()] (0 ms)
net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest]/[method:randomIsRequired()] (0 ms)
net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest]/[method:randomIsRequired()] (0 ms)
net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest]/[method:canHandleRequireSelection()] (0 ms)
net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest]/[method:canHandle()] (0 ms)
net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest]/[method:randomIsRequired()] (0 ms)
net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest]/[method:canHandleRequireSelection()] (0 ms)
net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest]/[method:canHandleRequireSelection()] (0 ms)
net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest]/[method:canHandleRequireSelection()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:constructorRequiresSelectiveRefinementTournament()] (0 ms)
net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest]/[method:canHandleRequireSelection()] (0 ms)
net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest]/[method:canHandle()] (0 ms)
net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest]/[method:canHandle()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:constructorRequiresRandomGenerator()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:randomIndividualRequiresPopulation()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresNonNullPopulation()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForFitnessRequiresNonNullPopulation()] (0 ms)
net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest]/[method:canHandle()] (1 ms)
net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest]/[method:canHandle()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresNonNullEAConfiguration()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForFitnessRequiresNonNullFitnessScore()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:randomIndividualRequiresFitnessScore()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresNonNullFitnessScore()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:randomIndividualRequiresNonEmptyFitnessScore()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresNonNegativeGeneration()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresPositiveNumIndividuals()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForFitnessRequiresNonEmptyFitnessScore()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementRequiresCandidateB()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:randomIndividualRequiresMatchingSizes()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementRequiresRefinementComparator()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementSelectsCandidateBWhenBetter()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementSelectsCandidateAWhenBetter()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementRequiresCandidateA()] (1 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectRequiresMatchingPopulationAndFitnessSize()] (0 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementRandomlySelectsWhenEqualHighValue()] (1 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForRefinementRandomlySelectsWhenEqual()] (1 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:randomIndividualReturnsValidIndividual()] (1 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectForFitnessSelectsBestFromTournament()] (1 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectWithoutRefinement()] (2 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectWithRefinementApplied()] (2 ms)
net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.SelectiveRefinementTournamentSelectorTest]/[method:selectWithMinimization()] (3 ms)
net.bmahe.genetics4j.core.replacement.ElitismImplTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.replacement.ElitismImplTest]/[method:ctorNoOffspringSelector()] (1 ms)
net.bmahe.genetics4j.core.replacement.ElitismImplTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.replacement.ElitismImplTest]/[method:ctorNoSurvivorSelector()] (1 ms)
net.bmahe.genetics4j.core.replacement.ElitismImplTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.replacement.ElitismImplTest]/[method:ctorNoElitismSpec()] (1 ms)
net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest]/[method:selectMaximize()] (1 ms)
net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest]/[method:selectMaximizing()] (1 ms)
net.bmahe.genetics4j.core.replacement.ElitismImplTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.replacement.ElitismImplTest]/[method:simple()] (2 ms)
net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.TournamentSelectionPolicyHandlerTest]/[method:selectMinimize()] (1 ms)
net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RandomSelectionPolicyHandlerTest]/[method:select()] (12 ms)
net.bmahe.genetics4j.core.replacement.ElitismImplTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.replacement.ElitismImplTest]/[method:atLeastSpecified()] (3 ms)
net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.MultiTournamentsSelectionPolicyHandlerTest]/[method:selectMaxThenMin()] (3 ms)
net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.RouletteWheelSelectionPolicyHandlerTest]/[method:selectMinimizing()] (3 ms)
net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest]/[method:selectMinimize()] (5 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testSystemConstruction()] (2 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testGetterMethods()] (3 ms)
net.bmahe.genetics4j.core.evaluation.FitnessEvaluatorVirtualThreadTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.evaluation.FitnessEvaluatorVirtualThreadTest]/[method:testVirtualThreadFactory()] (14 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testEvaluateOnceWithDifferentGenerations()] (4 ms)
net.bmahe.genetics4j.core.EASystemTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.EASystemTest]/[method:testEvaluateOnce()] (6 ms)
net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest.[engine:junit-jupiter]/[class:net.bmahe.genetics4j.core.selection.ProportionalTournamentSelectionPolicyHandlerTest]/[method:selectMaximize()] (78 ms)

Report generated by PIT 1.20.3

1		package net.bmahe.genetics4j.core.termination;
2
3		import java.time.Duration;
4		import java.util.Arrays;
5		import java.util.Comparator;
6		import java.util.List;
7		import java.util.Objects;
8		import java.util.Optional;
9
10		import org.apache.commons.lang3.Validate;
11
12		import net.bmahe.genetics4j.core.Genotype;
13		import net.bmahe.genetics4j.core.spec.AbstractEAConfiguration;
14
15		/**
16		* Utility class providing factory methods for creating common termination conditions in evolutionary algorithms.
17		*
18		* <p>Terminations provides a comprehensive set of pre-built termination criteria that can be used individually or
19		* combined to create complex stopping conditions for evolutionary algorithms. Each method returns a {@link Termination}
20		* instance that encapsulates the specific logic for determining when evolution should stop.
21		*
22		* <p>Available termination criteria include:
23		* <ul>
24		* <li><strong>Generation-based</strong>: Stop after a maximum number of generations</li>
25		* <li><strong>Time-based</strong>: Stop after a specified duration has elapsed</li>
26		* <li><strong>Fitness-based</strong>: Stop when fitness reaches certain thresholds</li>
27		* <li><strong>Convergence-based</strong>: Stop when fitness stops improving for a period</li>
28		* <li><strong>Logical combinations</strong>: Combine multiple criteria with AND/OR logic</li>
29		* </ul>
30		*
31		* <p>Termination criteria can be combined to create sophisticated stopping conditions:
32		*
33		* <pre>{@code
34		* // Stop after 100 generations OR when fitness reaches 0.95 OR after 5 minutes
35		* Termination<Double> complexTermination = Terminations.or(
36		* Terminations.ofMaxGeneration(100),
37		* Terminations.ofFitnessAtLeast(0.95),
38		* Terminations.ofMaxTime(Duration.ofMinutes(5)));
39		*
40		* // Stop only when BOTH conditions are met: good fitness AND stable evolution

Terminations.java

Mutations

Active mutators

Tests examined