Python: run through all integer combinations subject to a constraint (find the minimum of a function)

Question

I would like to find a way to return the set of all vectors [x_1,...,x_n] subject to the constraint x_1+...+x_n=constant, each x_i is a nonnegative integer, and the order doesn't matter. (so [1,1,1,2]=[2,1,1,1]). I have very little experience with programming but I've been working with Python (sage) for the past month or so.

In particular, I'm trying to find the minimum value of a 15-variable (symmetric) function over nonnegative integers (subject to a constraint), but I'd like to write a program to do it because I can use it for similar projects as well.

I have been trying to write a program for 4 days now, and I'm suddenly coming to the realization that I have to somehow recursively define my function...and I have no idea what to do. I have a code which does something similar to what I want (but it's no where near done). I'll post it even though I'm sure it's the least efficient way to do what I'm trying to do:

def each_comb_first_step(vec):
    row_num=floor(math.fabs((vec[0,vec.ncols()-1]-vec[0,vec.ncols()-2]))/2)+1
    mat=matrix(ZZ, row_num, vec.ncols(), 0)
    for j in range(row_num):
        mat[j]=vec
        vec[0,vec.ncols()-2]=vec[0,vec.ncols()-2]+1
        vec[0,vec.ncols()-1]=vec[0,vec.ncols()-1]-1
    return mat

def each_comb(num,const):
    vec1=matrix(ZZ,1,num,0)
    vec1[0,num-1]=const
    time=0
    steps=0
subtot=0
    for i in (2,..,num-1):
        steps=floor(const/(i+1))
        for j in (1,..,steps):
            time=j
            for k in (num-i-1,..,num-2):
                vec1[0,k]=time
                time=time+1
            subtot=0
            for l in range(num-1):
                subtot=subtot+vec1[0,l]
            vec1[0,num-1]=const-subtot
            mat1=each_comb_first_step(vec1)
            return mat1

Is there by any chance a function which already does this, or something similar? Any help or suggestions would be greatly appreciated.

Please reindent your code, I suspect that the return statement is not in the for loop. And also could you provide an example of using your fuctions. — Frodon
– Frodon, Commented Jul 22, 2013 at 23:28
Checkout combinations_with_replacement in the itertools module. — mtadd
– mtadd, Commented Jul 23, 2013 at 0:31

Community · Accepted Answer · 2017-05-23 12:23:16Z

A brute force solution is as follows:

import itertools as it

# Constraint function returns true if inputs meet constraint requirement
def constraint(x1, x2, x3, x4): 
    return x1 + x2 + x3 + x4 == 10

numbers = range(1,10)   #valid numbers (non-negative integers)
num_variables = 4       #size of number tuple to create

#vectors contains all tuples of 4 numbers that meet constraint
vectors = [t for t in it.combinations_with_replacement(numbers, num_variables)
           if constraint(*t)]

print vectors

outputs

[(1, 1, 1, 7), (1, 1, 2, 6), (1, 1, 3, 5), (1, 1, 4, 4), (1, 2, 2, 5), (1, 2, 3, 4), (1, 3, 3, 3), (2, 2, 2, 4), (2, 2, 3, 3)]

The running time is O(numbers**num_variables), so will probably be prohibitively slow with your 15 variable solution. You might want to look into linear programming techniques. There's a free course on Linear Optimization at the Cousera website that can be used to solve these sorts of problems much quicker.

Check out this Stack Overflow question for a link to a python module that is an integer constraint solver.

user2357112 · Accepted Answer · 2013-07-23 01:42:25Z

You want to find all fixed-length partitions of a given integer. This can be done iteratively or recursively. The idea behind the recursive algorithm is to add a helper parameter representing a lower bound on the values to allow in the partitions. Then, for every possible least value in the partition, make a recursive call to figure out the ways to construct the rest of the partition.

def fixed_length_partitions(n, k, min_value=0):
    """Yields all partitions of the integer n into k integers."""

    if k == 0:
        if n == 0:
            yield []
    else:
        for last_num in range(min_value, 1 + n//k):
            for nums in _flps(n-last_num, k-1, min_value=last_num):
                # Warning: mutative
                nums += [last_num]
                yield nums
_flps = fixed_length_partitions

An iterative algorithm would be much faster (avoiding a lot of Python function call overhead), but also less readable, since it'd essentially replace the Python call stack with an explicit list and end up making the control flow a lot more confusing.

Collectives™ on Stack Overflow

Python: run through all integer combinations subject to a constraint (find the minimum of a function)

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related