[SciPy-Dev] Proposed enhancement: pure Python implementation of LP simplex method (two-phase)

Pauli Virtanen pav@iki...
Fri Jul 30 03:49:31 CDT 2010


Fri, 30 Jul 2010 09:48:49 +0800, Enzo Michelangeli wrote:
[clip]
>>> http://projects.scipy.org/scipy/ticket/1252
>>
>> I think your "test case" could easily be turned into a unit test, which
>> would make the submission more complete.
> 
> Done.

Seems to work.

Some API nitpicks,

1)

Return a solution object rather than a tuple:

class NamedTuple(tuple):
    def __new__(cls, values, names):
        self = tuple.__new__(cls, values)
        for value, name in zip(values, names):
            setattr(self, name, value)
        return self

class Solution(NamedTuple):
    _fields = []
    def __new__(cls, *a, **kw):
        values = list(a)
        for name in cls._fields[len(values):]:
            values.append(kw.pop(name))
        if len(values) != len(cls._fields) or kw:
            raise ValueError("Invalid arguments")
        return NamedTuple.__new__(cls, values, cls._fields)

    def __repr__(self):
        return "%s%s" % (self.__class__.__name__,
                         NamedTuple.__repr__(self))

class LPSolution(Solution):
    """
    Solution to a linear programming problem

    Attributes
    ----------
    x
        The optimal solution
    min
        The optimal value
    is_bounded
        True if the solution is bounded; False if unbounded
    solvable
        True if the problem is solvable; False if unsolvable
    basis
        Indices of the basis of the solution.
    """
    _fields = ['x', 'min', 'is_bounded', 'solvable', 'basis']

def lp(...):
    ...
    return LPSolution(optx, zmin, is_bounded, sol, basis)


We could (and probably should) replace *all* cases in Scipy where a tuple 
is currently returned by this sort of pattern. It's backwards compatible, 
since the returned object is still some sort of a tuple.


2)

Don't print to stdout.

Use warnings.warn if you need to warn about something.


3)

Call

	c = np.asarray(c)
	A = np.asarray(A)
	b = np.asarray(b)

in the beginning -- good for convenience.


-- 
Pauli Virtanen



More information about the SciPy-Dev mailing list