def batch_uniform_one_mutation(
    population: np.ndarray, lb: np.ndarray, ub: np.ndarray
) -> np.ndarray:
    """Performs uniform one mutation in batches

    Args:
        population (np.ndarray): Batch of individuals to mutate
        lb (np.ndarray): Lower bound for each dimension
        up (np.ndarray): Upper bound for each dimension

    Raises:
        ValueError: If the dimension of the individuals do not match the bounds

    Returns:
        np.ndarray: mutated population
    """
    dimension = len(population[0])
    n_individuals = len(population)
    if len(lb) != len(ub) or dimension != len(lb):
        msg = f"The size of individuals ({dimension}) and bounds {len(lb)} is different in uniform_one_mutation"
        raise ValueError(msg)

    rng = np.random.default_rng(84793258734753)
    mutation_points = rng.integers(low=0, high=dimension, size=n_individuals)
    new_values = rng.uniform(
        low=lb[mutation_points], high=ub[mutation_points], size=n_individuals
    )

    population[np.arange(n_individuals), mutation_points] = new_values

    return population

def binary_tournament_selection(population: Sequence[IndType]) -> IndType:
    """Binary Tournament Selection Operator

    Args:
        population (Sequence): Population of individuals to select a parent from

    Raises:
        RuntimeError: If the population is empty

    Returns:
        Instance or Solution: New parent
    """
    if not population:
        msg = "Trying to selection individuals in an empty population."
        raise ValueError(msg)
    elif len(population) == 1:
        return population[0]
    else:
        idx1, idx2 = np.random.default_rng().integers(
            low=0, high=len(population), size=2
        )
        return max(population[idx1], population[idx2], key=attrgetter("fitness"))

def elitist_replacement(
    current_population: Sequence[IndType],
    offspring: Sequence[IndType],
    hof: int = 1,
) -> list[IndType]:
    """Returns a new population constructed using the Elitist approach.
    HoF number of individuals from the current + offspring populations are
    kept in the new population. The remaining individuals are selected from
    the offspring population.

    Args:
        current_population  Sequence[IndType],: Current population in the algorithm
        offspring  Sequence[IndType],: Offspring population
        hof (int, optional): _description_. Defaults to 1.

    Raises:
        ValueError: Raises if the sizes of the population are different

    Returns:
          list[IndType]:
    """
    if len(current_population) != len(offspring):
        msg = f"The size of the current population ({len(current_population)}) != size of the offspring ({len(offspring)}) in elitist_replacement"
        raise ValueError(msg)

    combined_population = sorted(
        itertools.chain(current_population, offspring),
        key=attrgetter("fitness"),
        reverse=True,
    )
    top = combined_population[:hof]
    return list(top + offspring[1:])

def first_improve_replacement(
    current_population: Sequence[IndType],
    offspring: Sequence[IndType],
) -> Sequence[IndType]:
    """Returns a new population produced by a greedy operator.
    Each individual in the current population is compared with its analogous in the offspring population
    and the best survives

    Args:
        current_population (Sequence[IndType]): Current population in the algorithm
        offspring (Sequence[IndType]): Offspring population

    Raises:
        ValueError: Raises if the sizes of the population are different

    Returns:
         Sequence[IndType]: New population
    """
    if len(current_population) != len(offspring):
        msg = f"The size of the current population ({len(current_population)}) != size of the offspring ({len(offspring)}) in first_improve_replacement"
        raise ValueError(msg)
    return [a if a > b else b for a, b in zip(current_population, offspring)]

def generational_replacement(
    current_population: Sequence[IndType],
    offspring: Sequence[IndType],
) -> Sequence[IndType]:
    """Returns the offspring population as the new current population

    Args:
        current_population (Sequence[IndType]): Current population in the algorithm
        offspring (Sequence[IndType]): Offspring population

    Raises:
        ValueError: Raises if the sizes of the population are different

    Returns:
         Sequence[IndType]: New population
    """
    if len(current_population) != len(offspring):
        msg = f"The size of the current population ({len(current_population)}) != size of the offspring ({len(offspring)}) in generational replacement"
        raise ValueError(msg)

    return offspring[:]

def one_point_crossover(individual: IndType, other: IndType) -> IndType:
    """One point crossover

    Args:
        individual Instance or Solution: First individual to apply crossover. Returned object
        other Instance or Solution: Second individual to apply crossover

    Raises:
        ValueError: When the len(ind_1) != len(ind_2)

    Returns:
        Instance or Solution: New individual
    """
    if len(individual) != len(other):
        msg = f"Individual of different length in uniform_crossover. len(ind) = {len(individual)} != len(other) = {len(other)}"
        raise ValueError(msg)

    offspring = individual.clone()
    cross_point = np.random.default_rng().integers(low=0, high=len(individual))
    offspring[cross_point:] = other[cross_point:]
    return offspring

def uniform_crossover(
    individual: IndType, other: IndType, cxpb: np.float64 = np.float64(0.5)
) -> IndType:
    """Uniform Crossover Operator for Instances and Solutions

    Args:
        individual (IndType): First individual to apply crossover. Returned object.
        other (IndType): Second individual to apply crossover
        cxpb (float64, optional): Crossover probability. Defaults to 0.5.

    Raises:
        ValueError: When the len(ind_1) != len(ind_2)

    Returns:
        ndarray: New individual
    """
    if len(individual) != len(other):
        msg = f"Individual of different length in uniform_crossover. len(ind) = {len(individual)} != len(other) = {len(other)}"
        raise ValueError(msg)

    probs = np.random.default_rng().random(size=len(individual))
    genotype = np.empty_like(individual)
    genotype = np.where(probs <= cxpb, individual, other)

    return individual.clone_with(variables=genotype)