def __init__(self):

pass

def nsga3_generate_reference_points(self, num_objectives, num_divisions):

"""

compositions = list(_nsga3_enumerate_compositions(num_objectives, num_divisions))

as_array = numpy.array(compositions, dtype=float)

return as_array / num_divisions

def nsga3_compute_ideal_point(self, fitness):

"""

return numpy.asarray(fitness).max(axis=0)

def nsga3_find_extreme_points(self, fitness, ideal_point,

epsilon=NSGA3_ASF_EPSILON):

"""

fitness = numpy.asarray(fitness, dtype=float)

num_objectives = ideal_point.shape[0]

# Shortfall from the ideal point on each objective. Always >= 0

# because the ideal is the column max.

shortfall = ideal_point - fitness

extremes = numpy.empty((num_objectives, num_objectives), dtype=float)

for axis in range(num_objectives):

# Weight is 1 on the target axis, tiny on every other axis.

weights = numpy.full(num_objectives, epsilon)

weights[axis] = 1.0

asf_per_solution = (shortfall / weights).max(axis=1)

# The lowest ASF wins. argmin returns the first occurrence so

# ties go to the lower index.

extremes[axis] = fitness[numpy.argmin(asf_per_solution)]

return extremes

def nsga3_compute_intercepts(self, extreme_points, ideal_point,

fallback_fitness):

"""

ideal_point = numpy.asarray(ideal_point, dtype=float)

extreme_points = numpy.asarray(extreme_points, dtype=float)

fallback_fitness = numpy.asarray(fallback_fitness, dtype=float)

# Worst per objective under maximization is the column minimum.

worst_per_objective = fallback_fitness.min(axis=0)

translated = extreme_points - ideal_point

try:

coefficients = numpy.linalg.solve(translated,

numpy.ones(ideal_point.shape[0]))

except numpy.linalg.LinAlgError:

return worst_per_objective

# A near-zero coefficient means 1/b is huge and the intercept is

# essentially undefined on that axis.

if numpy.any(numpy.abs(coefficients) < NSGA3_INTERCEPT_NEAR_ZERO):

return worst_per_objective

intercepts = ideal_point + 1.0 / coefficients

# Under maximization a valid intercept sits strictly below the

# ideal. If it does not, the normalization denominator would flip

# sign and produce nonsense values.

if numpy.any(intercepts >= ideal_point - NSGA3_INTERCEPT_NEAR_ZERO):

return worst_per_objective

# Cap the intercept at the worst observed value so we never

# extrapolate the hyperplane past the real data range.

overshoot = intercepts < worst_per_objective

intercepts = numpy.where(overshoot, worst_per_objective, intercepts)

# If capping leaves the gap |intercept - ideal| too small, reset

# that axis to the worst observed value.

collapsed = numpy.abs(intercepts - ideal_point) < NSGA3_INTERCEPT_NEAR_ZERO

intercepts = numpy.where(collapsed, worst_per_objective, intercepts)

return intercepts

def nsga3_normalize_fitness(self, fitness, ideal_point, intercepts):

"""

fitness = numpy.asarray(fitness, dtype=float)

ideal_point = numpy.asarray(ideal_point, dtype=float)

intercepts = numpy.asarray(intercepts, dtype=float)

denominator = intercepts - ideal_point

# Under PyGAD-max, intercepts sit below ideal so denominator is

# negative. Replace near-zero entries with a tiny negative value

# to keep the sign correct and avoid divide-by-zero.

safe_denominator = numpy.where(denominator > -NSGA3_INTERCEPT_NEAR_ZERO,

-NSGA3_INTERCEPT_NEAR_ZERO,

denominator)

raw = (fitness - ideal_point) / safe_denominator

return numpy.clip(raw, 0.0, 1.0)

def nsga3_associate_to_reference_points(self, normalized, reference_points):

"""

normalized = numpy.asarray(normalized, dtype=float)

reference_points = numpy.asarray(reference_points, dtype=float)

# Turn every reference point into a unit direction vector once.

unit_directions = reference_points / numpy.linalg.norm(reference_points,

axis=1,

keepdims=True)

# Dot products of every solution with every reference direction.

# Shape: (n_solutions, n_references).

dot_products = normalized @ unit_directions.T

# Project each solution onto each reference line.

# Shape: (n_solutions, n_references, n_objectives).

projections = dot_products[:, :, None] * unit_directions[None, :, :]

# Perpendicular component is what is left after subtracting the

# projection from the original solution.

perpendicular = normalized[:, None, :] - projections

distances = numpy.linalg.norm(perpendicular, axis=2)

nearest = numpy.argmin(distances, axis=1)

nearest_distance = distances[numpy.arange(len(normalized)), nearest]

return nearest, nearest_distance

def nsga3_niching_select(self,

critical_front_indices,

critical_front_associations,

critical_front_distances,

accepted_associations,

num_reference_points,

num_to_select):

"""

niche_counts = numpy.zeros(num_reference_points, dtype=int)

for reference_index in accepted_associations:

niche_counts[reference_index] += 1

remaining_positions = list(range(len(critical_front_indices)))

picked = []

while len(picked) < num_to_select and remaining_positions:

target_reference_index = _nsga3_pick_target_reference_point(

niche_counts, critical_front_associations, remaining_positions)

if target_reference_index is None:

break

candidates_at_target = [

position for position in remaining_positions

if critical_front_associations[position] == target_reference_index

]

chosen_position = _nsga3_pick_candidate_at_reference(

candidates_at_target,

critical_front_distances,

niche_counts[target_reference_index],

)

picked.append(critical_front_indices[chosen_position])

niche_counts[target_reference_index] += 1

remaining_positions.remove(chosen_position)

critical_front_associations,

remaining_positions):

"""

candidate_references = {

int(critical_front_associations[position])

for position in remaining_positions

}

if not candidate_references:

return None

min_niche_count = min(niche_counts[reference]

for reference in candidate_references)

return min(reference for reference in candidate_references

critical_front_distances,

niche_count_at_target):

"""

if niche_count_at_target == 0:

return min(candidates_at_target,

key=lambda position: critical_front_distances[position])

return candidates_at_target[

numpy.random.randint(len(candidates_at_target))

"""

if num_objectives == 1:

yield [num_divisions]

return

for first in range(num_divisions + 1):

for rest in _nsga3_enumerate_compositions(num_objectives - 1,

num_divisions - first):