More flexible variable_boundaries

[lldvdll]

Hi, thanks for maintaining this package. Massively appreciated.

variable_boundaries means that the values have to come from complete and evenly distributed ranges. I have 2 use cases which require more flexibility.

1. Allow a single value instead of boundaries - [x, x] doesn't work, "ValueError: low >= high". This could be solved with 2.
2. Allow arbitrary list instead of boundaries - e.g. a range with holes in it, or two split ranges, or even an arbitrary set of objects.

Another benefit to 2. would allow for a naiive weighting by passing lists with multiple occurences of values.

I'm going to take a stab at these myself. But I'm by no means fit to contribute reliably.

Thanks,

[PasaOpasen]

@dvimrandd Nice to meet u

I develop this package thinking about not only flexibility, but high performance. And I think it will be much optimized to realize ur logic outside of this package -- it will be much easy and faster.

For example:

1. if u wanna use only 1 value, it's better to make partial function to exclude this variable -- and this will work better
2. for ranges it's better to set bounds like [0, n-1] where n is the length of e. g. [1, 2, 3, 8, 9, 10] (or create ur own start generation for more hard situation)

[lldvdll]

Thanks for your prompt response.

I can see for the single value that excluding the variable is a far preferable and elegant solution. Thanks!

For the ranges, I want to make it a little more clear so we're definitely on the same page. Suppose that I want to assign variables a set of indices from [0, 1, 2, 3, 4]. But v1 can only be from [0, 1, 3, 4], and v2 can only be from [0, 1, 4]. The fitness function will aggregate across variables for each index [0, 1, 2, 3, 4]. I can see that using your solution, a mapping function can be applied within the fitness function to convert the variable specific indices to the global indices before aggregation. I will likely implement this solution so thanks a lot! But with more information, do you see a preferable alternative? FYI: This is, roughly speaking, for a scheduling style problem where global indices represent time periods, and variables represent activities which can have periodic or even arbitrary constrants on allowable itme ranges.

Again, appreciate your dev work and response

[PasaOpasen]

@dvimrandd The most optimal way is

all_indexes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

range1 = all_indexes[0:3] + all_indexes[7:]
range2 = all_indexes[3:7]

all_ranges = (range1, range2)

bounds = [(0, len(rg)) for rg in all_ranges]

def func_wrap(arr):
    new_arr = np.array([rg[i] for rg, i in zip(all_ranges, arr))
    return old_func(new_arr)

If u don't wanna hold big lists in memory or needs very difficult logic, write some indexes behavior in func_wrap. For main algorithm it will be much better to hold only lower and upper bound and u should think and transform your task to this simplest form