Adding (parameterized) linear programming dual transformation!

[emma58]

Fixes the complaints of several reasonable people

Summary/Motivation:

This PR adds a transformation in core to take the dual of a linear program. For the purposes of supporting bilevel programming, it also allows for this dual to be "parameterized" by certain variables--that is, the user can specify a list of Vars that are treated as data for the purposes of taking the dual (e.g., if they are the outer variables of a bilevel program with an LP inner problem).

Changes proposed in this PR:

• Adds core.lp_dual transformation.
• Adds a parameterized standard form writer to get the A, b, and c matrices for taking the dual.
• Adds a very vanilla Python implementation of CSR and CSC matrices for use in the above--we can't use scipy because we need to allow Pyomo expressions in sparse matrix representations

Legal Acknowledgement

By contributing to this software project, I have read the contribution guide and agree to the following terms and conditions for my contribution:

1. I agree my contributions are submitted under the BSD license.
2. I represent I am authorized to make the contributions and grant the license. If my employer has rights to intellectual property that includes these contributions, I represent that I have received permission to make contributions and grant the required license on behalf of that employer.

[emma58]

Adding comments from an in-person review with @jsiirola

[emma58]

@mrmundt @jsiirola Assuming tests pass, this is ready for review again.

[jsiirola]

There are some issues with this implementation:

1. it doesn't actually return a list. ;)
2. it doesn't actually validate the ctype for list-like inputs

Maybe the following would be a more robust alternative:

def __init__(self, ctype):
    if isinstance(ctype, Sequence):
        self._ctypes = set(ctype)
    else:
        self._ctypes = set([ctype])

def __call__(self, x):
    return list(self._process(x))

def _process(self, x):
    if hasattr(x, 'ctype'):
        if x.ctype not in self._ctypes:
            raise ValueError(" .... ")
        if x.is_indexed():
            yield from x.values()
        else:
            yield x
    elif isinstance(x, Sequence):
        for y in x:
            yield from self._process(y)
    else:
        raise ValueError(" ... ")

def domain_name(self):
    _names = ', '.join(ct.__name__ for ct in self._ctypes)
    if len(self._ctypes) > 1:
        _names = '[' + _names + ']'
    return f"ComponentDataList({_names})")

[emma58]

I actually really want it to both return and accept ComponentSets, but just took your suggestions otherwise (and renamed it accordingly)

[jsiirola]

This is very, very close

[jsiirola]

Some day (not today) we should refactor the sparse sets into pyomo.common

[jsiirola]

We don't want to convert the set() to a list: that is unnecessary and converts O(1) lookups into O(n). We should sort the names ... but again, we should only generate the names string if we are going to actually use it (i.e. before raising an exception).