PyGAD 3.9.2

Release Date: October 16, 2026.

1. Roulette wheel selection and stochastic universal selection no longer fail with fitness values near the float limits. In PyGAD 3.9.1, a fitness of -sys.float_info.max, which some libraries give a rejected solution, made the shifted values overflow, and parent selection raised IndexError. The values are now scaled before they are shifted or added. -inf and NaN get no chance, solutions with +inf fitness share every chance equally, and a population with no finite fitness raises a clear ValueError. Ordinary non-negative fitness keeps exactly the same probabilities.
2. Regression tests cover the most negative float, huge values of both signs, huge positive values, infinite and missing values, and full runs with both selectors. The pygad.utils submodule version is 1.5.12.

PyGAD 3.9.1

Release Date: October 16, 2026.

1. Roulette wheel selection and stochastic universal selection favor the better solutions when fitness values are negative. Before this change, each share was the fitness divided by the total, which flips the order for negative values: the fitness values -1 and -9 gave the worse solution 90% of the selections. Negative fitness values are now shifted by the smallest fitness first, so -1 and -9 become 8 and 0. This also covers mixed positive and negative values, and equal negative values give every solution the same chance. Fitness values that are all zero or above keep their exact previous behavior.
2. Regression tests cover negative, mixed-sign, equal negative, multi-objective, and large Python integer fitness, and a minimization run with each selector. The pygad.utils submodule version is 1.5.11.

PyGAD 3.9.0

Release Date: October 16, 2026.

1. Roulette wheel selection and stochastic universal selection sum fitness values in a floating-point type wide enough for the input. Large int64, uint64, float16, and float32 fitness values no longer overflow and raise ZeroDivisionError. Object arrays of Python integers keep exact values. See PR #381.
2. SBX crossover and polynomial mutation round integer results to the nearest integer instead of truncating them. For a gene with a finite gene space, the result moves to the nearest allowed value. Before this change, the highest value of an integer gene was almost never produced, values were pulled toward zero, and SBX could not keep a parent's highest value. Results for integer genes change for the same random seed. Float genes are not affected. See Conversion and Rounding Rules.
3. A new gene_categorical parameter marks genes whose values are categories with no order. For these genes, polynomial mutation picks one of the other allowed values at random and SBX crossover copies the value of one parent. The default None keeps the previous behavior. See Categorical Genes.
4. Regression tests cover reaching both ends of integer and finite gene spaces, balanced steps up and down, negative ranges, stepped and uneven spaces, and every gene_categorical validation rule and operator behavior. The pygad.helper and pygad.utils submodule versions are 1.4.7 and 1.5.10.

PyGAD 3.8.1

Release Date: October 11, 2026.

1. Random and adaptive mutation clip generated values to NumPy integer type limits before casting, fixing overflow errors and wraparound with types such as numpy.uint8 and numpy.int8. The same rule covers additive and replacement mutation, None gene-space entries, constraint candidates, and duplicate repair. Clipping applies only to explicitly requested NumPy integer types. See issue #379 and Conversion and Rounding Rules.
2. Python int conversion of candidate arrays and population columns uses explicit signed 64-bit storage across NumPy versions and platforms, fixing large-integer conversion and initialization failures on Windows with NumPy 1.x. Integer range sampling and bounded operators use the same storage limits. Parent selection and crossover share array allocation, preserving large integers throughout the lifecycle. Per-gene Python int elements keep their scalar type, and explicitly requested NumPy types keep their widths. Supplied Python int population values must fit in signed 64-bit storage; use gene_type=object for larger supplied integers. See Conversion and Rounding Rules.
3. Regression tests cover integer mutation limits, exact large-integer storage, initialization, constraints, duplicate repair, parent selection, crossover, and NSGA-III population growth. Windows CI checks both NumPy 1.24.4 and the latest NumPy release without version-specific implementation branches. The 16 pre-existing Windows failures with NumPy 1.24.4 are fixed, and no higher NumPy minimum is required. The pygad.helper and pygad.utils submodule versions are 1.4.6 and 1.5.8.

PyGAD 3.8.0

Release Date: October 9, 2026.

Watch the release video on YouTube.

1. Two-point crossover selects two distinct random cut points from 0 through num_genes, with every pair equally likely. The segment length can vary from one to all genes, and the single-gene case no longer raises a slicing error. See PR #371.

2. Swap mutation can select any pair of distinct gene positions, matching its documentation. Single-gene offspring are returned unchanged. See PR #375.

3. SBX crossover selects the lower or upper child with equal probability, removing the bias toward lower gene values. See PR #376.

4. Random and adaptive mutation can change permutations when allow_duplicate_genes=False leaves no unused replacement value. The fallback swaps compatible genes while preserving their numeric values, destination types, gene spaces, uniqueness, and constraints. Swapped genes are tracked within each mutation pass to prevent immediately undoing a swap. See PR #373.

5. Regression tests cover single-gene behavior, cut-point and swap-pair coverage, SBX symmetry and bounds, mixed gene types, constrained permutations, both adaptive mutation controls, and reproducibility. The pygad.utils submodule version is 1.5.2.

6. Parallel fitness evaluation now reuses its executor within each run() call, including adaptive offspring evaluation. Workers are shut down after normal completion, early stopping, and exceptions. Executors are excluded from checkpoints and worker snapshots.

7. Serial, thread, and process modes use the same fitness-cache rules and result validation. Adaptive mutation evaluates the actual offspring, supplies None for their not-yet-assigned population indices, preserves fractional fitness, and uses the correct retained-parent or elite fitness. These evaluations are included in num_fitness_evaluations and the evaluations_<N> stop criterion. See issues #195 and #201.

8. Process workers use cloudpickle payloads for callable and GA state, supporting local functions and continuation after loading a checkpoint. Current state is sent for each evaluation round; grouped tasks reduce repeated state transfers. No new dependency is required. See issues #121 and #250.

9. pygad.kerasga.predict() synchronizes calls sharing a model across threads and restores the model's original weights even after prediction errors. See issue #150.

10. Stochastic universal selection uses the requested num_parents for pointer spacing, so direct calls can select a different number of parents from num_parents_mating. Regression tests cover smaller and larger counts, equal-fitness sampling, objective vectors, and mixed gene types. See issue #85.

11. Scramble mutation shuffles the selected segment's values directly, removing the separate index shuffle and reversal. Every permutation of that segment is possible; its values, array dtype, and unselected genes are preserved. Seeded results can differ from earlier versions. See issue #76.

12. New examples explain replacing a loaded fitness function, starting fresh when the objective changes, and handling short final fitness batches. The lifecycle guide also explains progress reporting and the order of fitness evaluation and callbacks. See issues #263, #217, and #154.

13. Rank selection assigns descending selection weights to the best-to-worst sorted solutions, correcting a bias that gave worse solutions higher selection probabilities. Regression tests verify exact probabilities, original population indices, negative fitness, objective vectors, crowding distance, ties, and parent copies. See issue #120. Seeded rank-selection results can differ from earlier versions.

14. A new plot_lifecycle() method draws the lifecycle configured for a GA instance, including operators, callbacks, population replacement, generation loops, and stopping decisions. Stage annotations and a configuration panel show relevant settings, including gene types, batching, and offspring shapes. Use show_parameters=False for a compact view, save_dir to export SVG, PNG, or PDF, and show=False to create a chart without displaying it. Use transparent=True for a transparent background. Charts fit their labels and connectors with small outer margins. The method works before or after run() without executing user functions or changing GA state. A new example is available at examples/plots/example_plot_lifecycle.py. The pygad.visualize submodule version is 1.2.1.

15. Duplicate-gene repair now uses one shared implementation for generated and manual initial populations, crossover, mutation, and NSGA-III population growth. Custom crossover and mutation outputs and their callbacks are also repaired when allow_duplicate_genes=False. Finite domains are searched completely through replacement chains, including changes to earlier duplicate occurrences. Continuous candidates and additional searches for dependent constraints use sample_size.

16. Repair uses each destination gene's type, precision, and range, and validates constraints against complete candidate solutions. Mixed types are compared by their exact stored numeric values. Mixed types, sample_size=1, stepped spaces, per-gene ranges, and None entries are handled consistently. Impossible initialization spaces warn instead of accessing uninitialized attributes. Equal and reversed integer bounds are handled consistently. Swap fallback uses original continuous and None bounds instead of membership in cached samples. SBX and polynomial mutation convert and round generated values before repair and use their own bounds. The pygad.helper and pygad.utils submodule versions are 1.4.2 and 1.5.4.

17. A new examples/example_duplicate_gene_repair.py demonstrates repair through several genes. Regression tests compare small finite spaces with exhaustive search and cover long chains, impossible spaces, constraints, callbacks, mixed types, and reproducible runs.

18. Initial population creation and NSGA-III population growth share column sampling and preparation methods. Integer ranges are sampled directly instead of being allocated for each gene value. Generated range values remain within their bounds after conversion and rounding, with a descriptive error when the type and precision cannot represent any valid value. Supplied population dimensions are inferred before per-gene validation, overriding explicit dimensions. Supplied populations also apply gene constraints, and mixed numeric values retain their exact values during conversion. Empty and malformed populations are rejected early; tuple and NumPy gene-type specifications are accepted without modifying caller-owned inputs. The new `example...

1. Validation logic is applied to validate the num_generations parameter.
2. The num_generations parameter must be assigned a positive integer. Previously, any number (positive/negative, int/float) was accepted.
3. A new script called activation.py is added into the pygad.helper module to include the activation function used by the cnn and nn modules.
4. In the pygad.parent_selection.ParentSelection class, the stochastic_universal_selection() method now calls the wheel_cumulative_probs() method instead of repeating the code of calculating the probabilities used for parent selection.
5. The wheel_cumulative_probs() method in the pygad.parent_selection.ParentSelection class is refactored to reduce its computational time.
6. Use numpy.where() to decide which the source parent of each gene within the uniform_crossover() method in the utils/crossover.py script. The same was already applied to the scattered_crossover() method.
7. Add tests for the following modules:
   1. nn
   2. cnn
   3. gacnn
   4. kerasga
   5. torchga
8. Fix a bug in the visualize/plot.py script where the labels parameter of boxplot() has been renamed tick_labels in Matplotlib.
9. Fix a bug where the best_solutions_fitness list (instance attribute to pygad.GA) has the fitness of the last generation duplicated when an early stop happens inside the on_generation() callback. This made its size incompatible with the best_solutions list.
10. The documentation is refactored to solve many language issues and the Furo theme is applied. For easy navigation, the index is reformatted to only show the main sections. At each page, its index is shown at the right side. A new theme toggle button to change theme between light and dark.
11. Support of multi-objective optimization using the Non-Dominated Sorting Genetic Algorithm III (NSGA-III). NSGA-III replaces the crowding distance of NSGA-II with niching against a structured grid of reference points, so it scales better to problems with 4 or more objectives. The new NSGA3 class lives in the new pygad/utils/nsga3.py script and is mixed into the pygad.GA class the same way NSGA2 is.
12. Two new parent selection methods are added to support NSGA-III: 1) nsga3_selection() for plain NSGA-III selection, and 2) tournament_selection_nsga3() for the tournament variant. Use them by setting parent_selection_type to 'nsga3' or 'tournament_nsga3'.
13. A new parameter nsga3_num_divisions is added to the pygad.GA constructor. It is required when parent_selection_type is 'nsga3' or 'tournament_nsga3' and sets the number of divisions per objective axis used to build the structured reference points (the p parameter from Deb & Jain 2014). The total number of reference points is C(M + p - 1, p) where M is the number of objectives.
14. When sol_per_pop is smaller than the number of NSGA-III reference points, PyGAD raises a warning and grows the population to match before the generational loop starts.
15. A new crossover operator: Simulated Binary Crossover (SBX). Use it by setting crossover_type='sbx'. The shape of the spread is controlled by the new sbx_crossover_eta parameter (default 30).
16. A new mutation operator: polynomial mutation. Use it by setting mutation_type='polynomial'. The size of the change is controlled by the new polynomial_mutation_eta parameter (default 20).
17. Two new stop criteria: time_<seconds> stops the run when the time inside run() is at least the given number of seconds; evaluations_<N> stops the run when the number of fitness function calls reaches the given count. New instance attribute num_fitness_evaluations counts the calls.
18. A new submodule pygad.utils.quality_indicators with four functions to measure the quality of a Pareto front: hypervolume, inverted_generational_distance, generational_distance, and spacing.
19. A new submodule pygad.benchmarks with built-in benchmark problems. pygad.benchmarks.classic has Sphere, Rastrigin, Rosenbrock, Griewank, Schwefel, Ackley, and Himmelblau. pygad.benchmarks.zdt has the ZDT family (ZDT1, ZDT2, ZDT3, ZDT4, ZDT6). pygad.benchmarks.dtlz has DTLZ1, DTLZ2, DTLZ3, and DTLZ4. pygad.benchmarks.knapsack has the 0/1 Knapsack problem. Each class is callable with the PyGAD fitness signature and returns negated values (for the minimization-style problems) so PyGAD can maximize toward the original minimum.
20. Update the documentation to reflect the recent additions and changes to the library structure.
21. A new benchmark pygad.benchmarks.tsp with a TSP class for the Travelling Salesman Problem. The class accepts either 2D coordinates or a precomputed distance_matrix, exposes gene_space, gene_type, and allow_duplicate_genes for the permutation encoding, and returns the negative tour length as the fitness.
22. Two new example folders under /examples: examples/benchmarks/ has one runnable example per benchmark (classic, ZDT, DTLZ, knapsack, and TSP), and examples/quality_indicators/ has one runnable example per quality indicator (hypervolume, IGD, GD, and spacing).
23. plot_pareto_front_curve() now also supports 3 objectives (3D scatter). M >= 4 still raises and points to the new high-dimensional plots.
24. Seven new plot methods on pygad.GA. The first three work on the final population (no extra flag needed): plot_pareto_front_pcp() (parallel coordinates, any M >= 2), plot_pareto_front_scatter_matrix() (M-by-M pairwise scatter, best for M >= 4), and plot_pareto_front_heatmap() (solutions-by-objectives heatmap). The other four require save_solutions=True: plot_fitness_band() (per-generation min / mean / max with a shaded band), plot_non_dominated_hypervolume() (hypervolume of the non-dominated set per generation), plot_population_diversity() (mean pairwise distance per generation), and plot_pareto_front_evolution() (non-dominated set overlaid every k generations).
25. Fix a latent divide-by-zero in NSGA3.nsga3_normalize_fitness(). The safeguard for near-zero denominators used to collapse to 0 for tiny negative values (the realistic case under PyGAD-max), which silently produced wrong normalized values. The safeguard now keeps the negative sign.
26. Refactor the NSGA classes to keep each script focused. A new module pygad/utils/nsga.py hosts the NSGA mixin with non_dominated_sorting() and get_non_dominated_set(), which are shared between NSGA-II and NSGA-III. nsga2.py now only carries NSGA-II specific code (crowding_distance, sort_solutions_nsga2). nsga3.py now only carries the NSGA-III algorithm primitives. The nsga3_selection() and tournament_selection_nsga3() methods have moved to pygad/utils/parent_selection.py next to their NSGA-II counterparts. The engine-time helpers _bootstrap_nsga3_reference_points(), _nsga3_grow_population(), _nsga3_generate_extra_random_solutions(), and _nsga3_generate_single_random_gene() now live in pygad/utils/engine.py.
27. Rename NSGA-III novel names to start with nsga3_ so the algorithm-specific surface is easy to spot. Algorithm primitives become nsga3_generate_reference_points, nsga3_compute_ideal_point, nsga3_find_extreme_points, nsga3_compute_intercepts, nsga3_normalize_fitness, nsga3_associate_to_reference_points, and nsga3_niching_select. Module-level helpers gain the same prefix (_nsga3_pick_target_reference_point, _nsga3_pick_candidate_at_reference, _nsga3_enumerate_compositions, _nsga3_validate_multi_objective_fitness, _nsga3_accumulate_fronts). The constants are renamed NSGA3_ASF_EPSILON and NSGA3_INTERCEPT_NEAR_ZERO. Names that already had NSGA-II parallels (tournament_selection_nsga3, pareto_fronts, non_dominated_sorting) keep their original spelling.
28. Spell every name and docstring in American English (normalize, maximize, behavior, color, optimization, ...) so the library stays consistent.
29. Expand abbreviated names introduced by the NSGA-III refactor: fl_indices to critical_front_indices, fl_assoc to critical_front_associations, fl_dist to critical_front_distances, st_indices to selection_pool_indices, st_fitness to selection_pool_fitness, accepted_assoc to accepted_associations, K to num_to_select (in nsga3_niching_select).
30. The NSGA-III population auto-growth path now respects every initial-population rule: init_range_low/init_range_high, gene_space, gene_type (single dtype or nested per-gene [type, precision]), gene_constraint, and allow_duplicate_genes=False. Previously, only the gene-space / init-range sampling step was applied; gene constraints and duplicate resolution were skipped, which could leave the grown rows in an invalid state.
31. A new Report mixin in pygad/utils/report.py adds ga_instance.generate_report(filename, ...) to build a PDF report of the run. The report bundles a configuration table, a run-summary table, the best solution, and every applicable plot (auto-selected based on the run's properties: SOO vs MOO, number of objectives, save_solutions, save_best_solutions). The report uses reportlab and matplotlib, both available through the new optional dependency extra pip install pygad[report].
32. A new example examples/example_generate_report.py shows how to build a PDF report after running a multi-objective GA.
33. The pygad.md, releases.md, visualize.md, and utils.md documentation pages were updated to reflect the new module layout, the renamed methods, the new generate_report() entry point, and the new NSGA-III instance attributes (nsga3_num_divisions, nsga3_reference_points). The "Other Instance Attributes & Methods" section in pygad.md is now grouped by area (Lifecycle, Population, Fitness, Parent Selection, NSGA-II, NSGA-III, Crossover, Mutation, Elitism, Gene Constraints, Saving) so each method or attribute appears ...

1. Support passing a class to the fitness, crossover, and mutation. #342

2. A new class called Validation is created in the new pygad/utils/validation.py script. It has a method called validate_parameters() to validate all the parameters passed while instantiating the pygad.GA class.

3. Refactoring the pygad.py script by moving a lot of functions and methods to other classes in other scripts.

4. The summary() method was moved to Helper class in the pygad/helper/misc.py script.

5. The validation code in the __init__() method of the pygad.GA class is moved to the new validate_parameters() method in the new Validation class in the new pygad/utils/validation.py script. Moreover, the validate_multi_stop_criteria() method is also moved to the same class.

6. The GA main workflow is moved into the new GAEngine class in the new pygad/utils/engine.py script. Specifically, these methods are moved from the pygad.GA class to the new GAEngine class:
   1. run()
   1. run_loop_head()
   2. run_select_parents()
   3. run_crossover()
   4. run_mutation()
   5. run_update_population()
   2. initialize_population()
   3. cal_pop_fitness()
   4. best_solution()
   5. round_genes()

7. The pygad.GA class now extends the two new classes utils.validation.Validation and utils.engine.GAEngine.

8. The version of the pygad.utils submodule is upgraded from 1.3.0 to 1.4.0.

9. The version of the pygad.helper submodule is upgraded from 1.2.0 to 1.3.0.

10. The version of the pygad.visualize submodule is upgraded from 1.1.0 to 1.1.1.

11. The version of the pygad.nn submodule is upgraded from 1.2.1 to 1.2.2.

12. The version of the pygad.cnn submodule is upgraded from 1.1.0 to 1.1.1.

13. The version of the pygad.torchga submodule is upgraded from 1.4.0 to 1.4.1.

14. The version of the pygad.kerasga submodule is upgraded from 1.3.0 to 1.3.1.

15. Update the elitism after the evolution ends to fix issue where the best solution returned by the best_solution() method is not correct. #337

16. Fix a bug in calling the numpy.reshape() function. The parameter newshape is removed since it is no longer supported started from NumPy 2.4.0. https://numpy.org/doc/stable/release/2.4.0-notes.html#removed-newshape-parameter-from-numpy-reshape

17. A minor change in the documentation is made to replace the newshape parameter when calling numpy.reshape().

18. Fix a bug in the visualize/plot.py script that causes a warning to be given when the plot leged is used with single-objective problems.

19. A new method called initialize_parents_array() is added to the Helper class in the pygad/helper/misc.py script. It is usually called from the methods in the ParentSelection class in the pygad/utils/parent_selection.py script to initialize the parents array.

20. Add more tests about:
    1. Operators (crossover, mutation, and parent selection).
    2. The best_solution() method.
    3. Parallel processing.
    4. The GANN module.
    5. The plots created by the visualize.

21. Instead of using repeated code for converting the data type and rounding the genes during crossover and mutation, the change_gene_dtype_and_round() method is called from the pygad.helper.misc.Helper class.

22. Fix some documentation issues. #336

23. Update the documentation to reflect the recent additions and changes to the library structure.

1. Fix a bug when minus sign (-) is used inside the stop_criteria parameter for multi-objective problems. #314 #323
2. Fix a bug when the stop_criteria parameter is passed as an iterable (e.g. list) for multi-objective problems (e.g. ['reach_50_60', 'reach_20, 40']). #314
3. Call the get_matplotlib() function from the plot_genes() method inside the pygad.visualize.plot.Plot class to import the matplotlib library. #315
4. Create a new helper method called select_unique_value() inside the pygad/helper/unique.py script to select a unique gene from an array of values.
5. Create a new helper method called get_random_mutation_range() inside the pygad/utils/mutation.py script that returns the random mutation range (min and max) for a single gene by its index.
6. Create a new helper method called change_random_mutation_value_dtype inside the pygad/utils/mutation.py script that changes the data type of the value used to apply random mutation.
7. Create a new helper method called round_random_mutation_value() inside the pygad/utils/mutation.py script that rounds the value used to apply random mutation.
8. Create the pygad/helper/misc.py script with a class called Helper that has the following helper methods:
   1. change_population_dtype_and_round(): For each gene in the population, round the gene value and change the data type.
   2. change_gene_dtype_and_round(): Round the change the data type of a single gene.
   3. mutation_change_gene_dtype_and_round(): Decides whether mutation is done by replacement or not. Then it rounds and change the data type of the new gene value.
   4. validate_gene_constraint_callable_output(): Validates the output of the user-defined callable/function that checks whether the gene constraint defined in the gene_constraint parameter is satisfied or not.
   5. get_gene_dtype(): Returns the gene data type from the gene_type instance attribute.
   6. get_random_mutation_range(): Returns the random mutation range using the random_mutation_min_val and random_mutation_min_val instance attributes.
   7. get_initial_population_range(): Returns the initial population values range using the init_range_low and init_range_high instance attributes.
   8. generate_gene_value_from_space(): Generates/selects a value for a gene using the gene_space instance attribute.
   9. generate_gene_value_randomly(): Generates a random value for the gene. Only used if gene_space is None.
   10. generate_gene_value(): Generates a value for the gene. It checks whether gene_space is None and calls either generate_gene_value_randomly() or generate_gene_value_from_space().
   11. filter_gene_values_by_constraint(): Receives a list of values for a gene. Then it filters such values using the gene constraint.
   12. get_valid_gene_constraint_values(): Selects one valid gene value that satisfy the gene constraint. It simply calls generate_gene_value() to generate some gene values then it filters such values using filter_gene_values_by_constraint().
9. Create a new helper method called mutation_process_random_value() inside the pygad/utils/mutation.py script that generates constrained random values for mutation. It calls either generate_gene_value() or get_valid_gene_constraint_values() based on whether the gene_constraint parameter is used or not.
10. A new parameter called gene_constraint is added. It accepts a list of callables (i.e. functions) acting as constraints for the gene values. Before selecting a value for a gene, the callable is called to ensure the candidate value is valid. Check the [Gene Constraint](https://pygad.readthedocs.io/en/latest/pygad_more.html#gene-constraint) section for more information. #119
11. A new parameter called sample_size is added. To select a gene value that respects a constraint, this variable defines the size of the sample from which a value is selected randomly. Useful if either allow_duplicate_genes or gene_constraint is used. An instance attribute of the same name is created in the instances of the pygad.GA class. Check the [sample_size Parameter](https://pygad.readthedocs.io/en/latest/pygad_more.html#sample-size-parameter) section for more information.
12. Use the sample_size parameter instead of num_trials in the methods solve_duplicate_genes_randomly() and unique_float_gene_from_range() inside the pygad/helper/unique.py script. It is the maximum number of values to generate as the search space when looking for a unique float value out of a range.
13. Fixed a bug in population initialization when allow_duplicate_genes=False. Previously, gene values were checked for duplicates before rounding, which could allow near-duplicates like 7.61 and 7.62 to pass. After rounding (e.g., both becoming 7.6), this resulted in unintended duplicates. The fix ensures gene values are now rounded before duplicate checks, preventing such cases.
14. More tests are created.
15. More examples are created.
16. Edited the sort_solutions_nsga2() method in the pygad/utils/nsga2.py script to accept an optional parameter called find_best_solution when calling this method just to find the best solution.
17. Fixed a bug while applying the non-dominated sorting in the get_non_dominated_set() method inside the pygad/utils/nsga2.py script. It was swapping the non-dominated and dominated sets. In other words, it used the non-dominated set as if it is the dominated set and vice versa. All the calls to this method were edited accordingly. #320.
18. Fix a bug retrieving in the best_solution() method when retrieving the best solution for multi-objective problems. #331

1. The delay_after_gen parameter is removed from the pygad.GA class constructor. As a result, it is no longer an attribute of the pygad.GA class instances. To add a delay after each generation, apply it inside the on_generation callback. #283
2. In the single_point_crossover() method of the pygad.utils.crossover.Crossover class, all the random crossover points are returned before the for loop. This is by calling the numpy.random.randint() function only once before the loop to generate all the K points (where K is the offspring size). This is compared to calling the numpy.random.randint() function inside the for loop K times, once for each individual offspring.
3. Bug fix in the examples/example_custom_operators.py script. #285
4. While making prediction using the pygad.torchga.predict() function, no gradients are calculated.
5. The gene_type parameter of the pygad.helper.unique.Unique.unique_int_gene_from_range() method accepts the type of the current gene only instead of the full gene_type list.
6. Created a new method called unique_float_gene_from_range() inside the pygad.helper.unique.Unique class to find a unique floating-point number from a range.
7. Fix a bug in the pygad.helper.unique.Unique.unique_gene_by_space() method to return the numeric value only instead of a NumPy array.
8. Refactoring the pygad/helper/unique.py script to remove duplicate codes and reformatting the docstrings.
9. The plot_pareto_front_curve() method added to the pygad.visualize.plot.Plot class to visualize the Pareto front for multi-objective problems. It only supports 2 objectives. #279
10. Fix a bug converting a nested NumPy array to a nested list. #300
11. The Matplotlib library is only imported when a method inside the pygad/visualize/plot.py script is used. This is more efficient than using import matplotlib.pyplot at the module level as this causes it to be imported when pygad is imported even when it is not needed. #292
12. Fix a bug when minus sign (-) is used inside the stop_criteria parameter (e.g. stop_criteria=["saturate_10", "reach_-0.5"]). #296
13. Make sure self.best_solutions is a list of lists inside the cal_pop_fitness method. #293
14. Fix a bug where the cal_pop_fitness() method was using the previous_generation_fitness attribute to return the parents fitness. This instance attribute was not using the fitness of the latest population, instead the fitness of the population before the last one. The issue is solved by updating the previous_generation_fitness attribute to the latest population fitness before the GA completes. #291

1. After the last generation and before the run() method completes, update the 2 instance attributes: 1) last_generation_parents 2) last_generation_parents_indices. This is to keep the list of parents up-to-date with the latest population fitness last_generation_fitness. #275
2. 4 methods with names starting with run_. Their purpose is to keep the main loop inside the run() method clean. Check the [Other Methods](https://pygad.readthedocs.io/en/latest/pygad.html#other-methods) section for more information.