itools | Python library with tons of features

Hmmmm... Interesting problem. So in the example...

• itools.product([ range(10), range(10), range(10), range(10), range(10) ])

...each range of [-10, -9, ..., 0, ..., 9, 10] contains 21 values, and therefore the total number of combinations is...

• 21 * 21 * 21 * 21 * 21 = 4,084,101 combinations

If the logic is to find any combination that includes -10 or 10, then I believe the total edges can be calculated as follows. Take the first range and simply make it [-10, 10] and then iterate over every combination of the remaining ranges. This will result in an edge count of...

• Step 1: 2 * 21 * 21 * 21 * 21 = 388962 edges

...and then take the next range and simply make it [-10, 10] but limit the first range to [-9, -8, ..., 0, ..., 8, 9] because we've already covered all instances of the first range where the values are [-10, 10]. This second step then contains an edge count of...

• Step 2: 19 * 2 * 21 * 21 * 21 = 351918 edges

...and continuing this logic through the remaining ranges...

• Step 3: 19 * 19 * 2 * 21 * 21 = 318402 edges
• Step 4: 19 * 19 * 19 * 2 * 21 = 288078 edges
• Step 5: 19 * 19 * 19 * 19 * 2 = 260642 edges

...for a total edge count of...

• 1,608,002 edges.

This edge count represents 39.4% (!) of the total combinations ( 1,608,002 / 4,084,101 ).

That being the case, in this example, you might be able to cut the time by a little more than half if creating a combination generator that follows the logic in Steps 1 - 5, guaranteeing that every result is an edge. But this added algorithmic complexity might not be worth the effort if performance is not an issue when scanning all combinations. Ie, you won't be saving magnitudes of checks compared to simply scanning all combinations.

I believe that the smaller that coeff is, the higher the percentage of edges relative to all combinations. In fact, the example of itools.product([ range(1), range(1) ]) has a 89% edge ratio.

So unless taking on very large coeff, am not sure introducing the complexity of generating only the edges is worth the effort. Something to think about and assess, though, given the expected ranges and dimensions you anticipate...

EDIT: A brute force confirmation of edge count

The following code is a brute force means of driving out all edge combinations. Note that given a range of 10 with 5 dimensions, the algorithm essentially treats the combinations as a base 21 problem, so instead of a range of (-10, 10), the algorithm assumes a range of (0, 20) and looks for cases where a digit is either 0 or 20.

NOTE: This will take a few seconds to run!