jMetalPy

jMetalPy strictly follows the Object-oriented programming paradigm. Avoid imperative or functional programming styles.

Attribute Access

• Attributes should generally be public and accessed directly.
• Do not use standard getter/setter methods (e.g., get_value()/set_value()) as they are not idiomatic in Python.
• If you need to implement additional logic during attribute access, use the @property decorator or the property() function. This allows users to continue accessing the attribute directly while you maintain control over the logic.

class MyClass:
    def __init__(self):
        self._value = 0

    @property
    def value(self) -> int:
        # Additional logic here
        return self._value

    @value.setter
    def value(self, new_val: int):
        # Additional logic here
        self._value = new_val

# Usage remains direct:
obj = MyClass()
obj.value = 10  # Uses setter
print(obj.value) # Uses getter

The project uses modern Python typing and data structures. Follow these patterns:

• Immutable Data: Use @dataclass(slots=True, frozen=True) for stateless, immutable data like configuration objects, DTOs, or parameter bundles.
  • CRITICAL: Do not use frozen=True for Solution or other mutable containers that algorithms modify in place (e.g., during crossover, mutation, or repair), as this forces expensive copy-on-write operations in evolutionary loops.
• Discrete Choices: Prefer Enum for sets of discrete choices.
• Typing Syntax: Use modern syntax such as | for unions, TypeAlias, Literal, Final, TypedDict, and Self.
• Annotations: Annotate parameters, return types, and key variables in all new or modified code.
• Note on Static Analysis: While the project encourages typing, mypy is not enforced in CI. However, contributors are encouraged to use it locally.

DistanceBasedArchive is an adaptive archive designed to maintain diverse solution sets in multi-objective optimization. It automatically switches its selection strategy based on the number of objectives in the solutions it receives:

• 2 objectives: Uses crowding distance selection to maximize diversity.
• >2 objectives: Uses distance-based subset selection with normalization.

This makes it a versatile tool for both bi-objective and many-objective optimization problems without requiring manual configuration changes when the objective count changes.

from jmetal.util.archive import DistanceBasedArchive
from jmetal.core.solution import FloatSolution

# Automatically handles 2 objectives via crowding distance
archive = DistanceBasedArchive(maximum_size=10)

# Automatically handles >2 objectives via distance-based selection
archive_many = DistanceBasedArchive(maximum_size=10)

jMetalPy uses a specific branching model to manage development.

Constant Branches

• master: Contains production-ready code. Merges from develop or hotfix branches must include a TAG.
• develop: The integration branch for the next release. Receives merges from feature/ and fix/ branches.

Temporary Branches

• feature/<task-id>-<description>: Used for new functionality. Created from develop and merged back into develop.
• fix/<task-id>-<description>: Used for corrections. Created from develop and merged back into develop.
• hotfix/<task-id>-<description>: Used for production emergencies. Created from master and merged into both master and develop.

Contribution Steps

1. Create a local branch and upload it to the remote server immediately to enable automated verification.
2. Push frequently to trigger automated tests.
3. Once development is complete and tests pass, create a Pull Request.
4. Important: Remove your local and remote branch once the merge is finalized.

Useful Commands

git fetch --prune

To use the DistanceBasedArchive, instantiate it with a maximum_size. You can then add solutions using the .add(solution) method, which returns a boolean indicating if the solution was added. Use .size() to get the current count and .get(index) to retrieve solutions.

from jmetal.util.archive import DistanceBasedArchive
from jmetal.core.solution import FloatSolution

# Create archive with maximum size of 10
archive = DistanceBasedArchive(maximum_size=10)

# Create some example solutions
solutions = []
for i in range(20):
    solution = FloatSolution([], [], 2)  # 2 objectives
    solution.objectives = [i/20.0, 1.0 - i/20.0]  # Trade-off front
    solutions.append(solution)

# Add solutions to archive
for solution in solutions:
    was_added = archive.add(solution)
    print(f"Solution {solution.objectives} added: {was_added}")

print(f"Final archive size: {archive.size()}")
print("Selected solutions:")
for i in range(archive.size()):
    sol = archive.get(i)
    print(f"  {sol.objectives}")