jeffrey-hokanson / PSDR / 377

pending completion

Build # 377

Build Type

push

travis-ci-com

Committed by

jeffrey-hokanson

Commit Message

removed unnecessary check

Run Details

1273 of 1732 branches covered (73.5%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

78 existing lines in 2 files now uncovered.

4724 of 5316 relevant lines covered (88.86%)

3.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.56

/psdr/domains/linquad.py

r""" LinQuadDomain definition

Philosophically, LinQuad domains consist of those convex domains specified by a combination
of linear inequality, linear equality, and quadratic inequality constraints.

From a code perspective, this is where a dependency on CVXPY is introduced to 
handle domain properities from within this domain

"""

from __future__ import division

import numpy as np
import cvxpy as cp
from .domain import TOL, DEFAULT_CVXPY_KWARGS
from .euclidean import EuclideanDomain
from .tensor import TensorProductDomain

from ..misc import merge

class LinQuadDomain(EuclideanDomain):
        r"""A domain specified by a combination of linear (in)equality constraints and convex quadratic constraints


        Here we define a domain that is specified in terms of bound constraints,
        linear inequality constraints, linear equality constraints, and quadratic constraints.

        .. math::

                \mathcal{D} := \left \lbrace
                        \mathbf{x} : \text{lb} \le \mathbf{x} \le \text{ub}, \ 
                        \mathbf{A} \mathbf{x} \le \mathbf{b}, \
                        \mathbf{A}_{\text{eq}} \mathbf{x} = \mathbf{b}_{\text{eq}}, \
                        \| \mathbf{L}_i (\mathbf{x} - \mathbf{y}_i)\|_2 \le \rho_i
                \right\rbrace \subset \mathbb{R}^m


        Parameters
        ----------
        A: array-like (m,n)
                Matrix in left-hand side of inequality constraint
        b: array-like (m,)
                Vector in right-hand side of the ineqaluty constraint
        A_eq: array-like (p,n)
                Matrix in left-hand side of equality constraint
        b_eq: array-like (p,) 
                Vector in right-hand side of equality constraint
        lb: array-like (n,)
                Vector of lower bounds 
        ub: array-like (n,)
                Vector of upper bounds 
        Ls: list of array-likes (p,m)
                List of matrices with m columns defining the quadratic constraints
        ys: list of array-likes (m,)
                Centers of the quadratic constraints
        rhos: list of positive floats 
                Radii of quadratic constraints
        names: list of strings, optional
                Names for each of the parameters in the space
        kwargs: dict, optional
                Additional parameters to be passed to cvxpy Problem.solve() 
        """
        def __init__(self, A = None, b = None, 
                lb = None, ub = None, 
                A_eq = None, b_eq = None, 
                Ls = None, ys = None, rhos = None,
                names = None, **kwargs):

                self.tol = 1e-6
                # Determine dimension of space
                self._init_dim(lb = lb, ub = ub, A = A, A_eq = A_eq, Ls = Ls)

                # Start setting default values
                self._lb = self._init_lb(lb)
                self._ub = self._init_ub(ub)
                self._A, self._b = self._init_ineq(A, b)
                self._A_eq, self._b_eq = self._init_eq(A_eq, b_eq)        
                self._Ls, self._ys, self._rhos = self._init_quad(Ls, ys, rhos)
                
                self._init_names(names)        

                
                self.kwargs = merge(DEFAULT_CVXPY_KWARGS, kwargs)

        def __str__(self):
                ret = "<%s on R^%d" % (self.__class__.__name__, len(self))
                if len(self._Ls) > 0:
                        ret += "; %d quadratic constraints" % (len(self._Ls),)
                if self._A.shape[0] > 0:
                        ret += "; %d linear inequality constraints" % (self._A.shape[0], )
                if self._A_eq.shape[0] > 0:
                        ret += "; %d linear equality constraints" % (self._A_eq.shape[0], )
                ret +=">"

                return ret
        
        
        ################################################################################                
        # Initialization helpers 
        ################################################################################                
        def _init_dim(self, lb = None, ub = None, A = None, A_eq = None, Ls = None):
                """determine the dimension of the space we are working on"""
                if lb is not None:
                        if isinstance(lb, (int, float)):
                                m = 1
                        else:
                                m = len(lb)
                elif ub is not None:
                        if isinstance(ub, (int, float)):
                                m = 1
                        else:
                                m = len(ub)
                elif A is not None:
                        m = len(A[0])
                elif A_eq is not None:
                        m = len(A_eq[0])
                elif Ls is not None:
                        m = len(Ls[0][0])
                else:
                        raise Exception("Could not determine dimension of space")

                self._dimension = m


        def _init_lb(self, lb):
                if lb is None:
                        return -np.inf*np.ones(len(self))
                else:
                        if isinstance(lb, (int, float)):
                                lb = [lb]
                        assert len(lb) == len(self), "Lower bound has wrong dimensions"
                        return np.array(lb)
                
        def _init_ub(self, ub):
                if ub is None:
                        return np.inf*np.ones(len(self))
                else:
                        if isinstance(ub, (int, float)):
                                ub = [ub]
                        assert len(ub) == len(self), "Upper bound has wrong dimensions"
                        return np.array(ub)
                
        def _init_ineq(self, A, b):
                if A is None and b is None:
                        A = np.zeros((0,len(self)))
                        b = np.zeros((0,))
                elif A is not None and b is not None:
                        A = np.array(A)
                        b = np.array(b)
                        if len(b.shape) == 0:
                                b = b.reshape(1)

                        assert len(b.shape) == 1, "b must have only one dimension"
                        
                        if len(A.shape) == 1 and len(b) == 1:
                                A = A.reshape(1,-1)
        
                        assert A.shape[1] == len(self), "A has wrong number of columns"
                        assert A.shape[0] == b.shape[0], "The number of rows of A and b do not match"
                else:
                        raise AssertionError("If using inequality constraints, both A and b must be specified")
                return A, b        
        
        def _init_eq(self, A_eq, b_eq):
                if A_eq is None and b_eq is None:
                        A_eq = np.zeros((0,len(self)))
                        b_eq = np.zeros((0,))
                elif A_eq is not None and b_eq is not None:
                        A_eq = np.array(A_eq)
                        b_eq = np.array(b_eq)
                        if len(b_eq.shape) == 0:
                                b_eq = b_eq.reshape(1)

                        assert len(b_eq.shape) == 1, "b_eq must have only one dimension"
                        
                        if len(A_eq.shape) == 1 and len(b_eq) == 1:
                                A_eq = A_eq.reshape(1,-1)

                        assert A_eq.shape[1] == len(self), "A_eq has wrong number of columns"
                        assert A_eq.shape[0] == b_eq.shape[0], "The number of rows of A_eq and b_eq do not match"
                else:
                        raise AssertionError("If using equality constraints, both A_eq and b_eq must be specified")
                
                return A_eq, b_eq

        def _init_quad(self, Ls, ys, rhos):
                if Ls is None and ys is None and rhos is None:
                        _Ls = []
                        _ys = []
                        _rhos = []
                elif Ls is not None and ys is not None and rhos is not None:
                        assert len(Ls) == len(ys) == len(rhos), "Length of all quadratic constraints must be the same"
                        
                        _Ls = []
                        _ys = []
                        _rhos = []
                        for L, y, rho in zip(Ls, ys, rhos):
                                assert len(L[0]) == len(self), "dimension of L doesn't match the domain"
                                assert len(y) == len(self), "Dimension of center doesn't match the domain"
                                assert rho > 0, "Radius must be positive"
                                _Ls.append(np.array(L))
                                _ys.append(np.array(y))
                                _rhos.append(rho)
                                # TODO: If constraint is rank-1, should we implicitly convert to a linear inequality constriant
                else:
                        raise AssertionError("If providing quadratic constraint, each of Ls, ys, and rhos must be defined") 
                return _Ls, _ys, _rhos 

        ################################################################################                
        # Simple properties
        ################################################################################                
        def __len__(self): return self._dimension
        
        @property
        def lb(self): return self._lb
        
        @property
        def ub(self): return self._ub

        @property
        def A(self): return self._A

        @property
        def b(self): return self._b

        @property
        def A_eq(self): return self._A_eq

        @property
        def b_eq(self): return self._b_eq

        @property
        def Ls(self): return self._Ls

        @property
        def ys(self): return self._ys
        
        @property
        def rhos(self): return self._rhos



                
        ################################################################################                
        # Normalization 
        ################################################################################                
        def _normalized_domain(self, **kwargs):
                names_norm = [name + ' (normalized)' for name in self.names]
                
                return LinQuadDomain(lb = self.lb_norm, ub = self.ub_norm, A = self.A_norm, b = self.b_norm, 
                        A_eq = self.A_eq_norm, b_eq = self.b_eq_norm, Ls = self.Ls_norm, ys = self.ys_norm, rhos = self.rhos_norm,
                        names = names_norm, **merge(self.kwargs, kwargs))

        def _isinside(self, X, tol = TOL):
                return self._isinside_bounds(X, tol = tol) & self._isinside_ineq(X, tol = tol) & self._isinside_eq(X, tol = tol) & self._isinside_quad(X, tol = tol)

        def _extent(self, x, p):
                # Check that direction satisfies equality constraints to a tolerance
                if self.A_eq.shape[0] == 0 or np.all(np.abs(self.A_eq.dot(p) ) < self.tol):
                        return min(self._extent_bounds(x, p), self._extent_ineq(x, p), self._extent_quad(x, p))
                else:
                        return 0. 

        ################################################################################                
        # Convex Solver Functions 
        ################################################################################                

        def _build_constraints_norm(self, x_norm):
                r""" Build the constraints corresponding to the domain given a vector x
                """
                constraints = []
                
                # Numerical issues emerge with unbounded constraints
                I = np.isfinite(self.lb_norm)
                if np.sum(I) > 0:
                        constraints.append( self.lb_norm[I] <= x_norm[I])
                
                I = np.isfinite(self.ub_norm)
                if np.sum(I) > 0:
                        constraints.append( x_norm[I] <= self.ub_norm[I])
        
                if self.A.shape[0] > 0:        
                        constraints.append( x_norm.__rmatmul__(self.A_norm) <= self.b_norm)
                if self.A_eq.shape[0] > 0:
                        constraints.append( x_norm.__rmatmul__(self.A_eq_norm) == self.b_eq_norm)

                for L, y, rho in zip(self.Ls_norm, self.ys_norm, self.rhos_norm):
                        if len(L) > 1:
                                constraints.append( cp.norm(x_norm.__rmatmul__(L) - L.dot(y)) <= rho )
                        elif len(L) == 1:
                                constraints.append( cp.norm(L*x_norm - L.dot(y)) <= rho)

                return constraints
        

        def _build_constraints(self, x):
                r""" Build the constraints corresponding to the domain given a vector x
                """
                constraints = []
                
                # Numerical issues emerge with unbounded constraints
                I = np.isfinite(self.lb)
                if np.sum(I) > 0:
                        constraints.append( self.lb[I] <= x[I])
                
                I = np.isfinite(self.ub)
                if np.sum(I) > 0:
                        constraints.append( x[I] <= self.ub[I])
                
                if self.A.shape[0] > 0:        
                        constraints.append( x.__rmatmul__(self.A) <= self.b)
                if self.A_eq.shape[0] > 0:
                        constraints.append( x.__rmatmul__(self.A_eq) == self.b_eq)

                for L, y, rho in zip(self.Ls, self.ys, self.rhos):
                        if len(L) > 1:
                                constraints.append( cp.norm(x.__rmatmul__(L) - L.dot(y)) <= rho )
                        elif len(L) == 1:
                                constraints.append( cp.norm(L*x - L.dot(y)) <= rho)

                return constraints
        

        ################################################################################                
        # 
        ################################################################################                

        def add_constraints(self, A = None, b = None, lb = None, ub = None, A_eq = None, b_eq = None,
                Ls = None, ys = None, rhos = None):
                r"""Add new constraints to the domain
                """
                lb = self._init_lb(lb)
                ub = self._init_ub(ub)
                A, b = self._init_ineq(A, b)
                A_eq, b_eq = self._init_eq(A_eq, b_eq)
                Ls, ys, rhos = self._init_quad(Ls, ys, rhos)

                # Update constraints
                lb = np.maximum(lb, self.lb)
                ub = np.minimum(ub, self.ub)

                A = np.vstack([self.A, A])        
                b = np.hstack([self.b, b])

                A_eq = np.vstack([self.A_eq, A_eq])
                b_eq = np.hstack([self.b_eq, b_eq])

                Ls = self.Ls + Ls
                ys = self.ys + ys
                rhos = self.rhos + rhos

                if len(Ls) > 0:
                        return LinQuadDomain(lb = lb, ub = ub, A = A, b = b, A_eq = A_eq, b_eq = b_eq,
                                 Ls = Ls, ys = ys, rhos = rhos, names = self.names)
                elif len(b) > 0 or len(b_eq) > 0:
                        from .linineq import LinIneqDomain
                        return LinIneqDomain(lb = lb, ub = ub, A = A, b = b, A_eq = A_eq, b_eq = b_eq, names = self.names)
                else:
                        from .box import BoxDomain
                        return BoxDomain(lb = lb, ub = ub, names = self.names)

        def __and__(self, other):
                if isinstance(other, LinQuadDomain) or (isinstance(other, TensorProductDomain) and other.is_linquad_domain):
                        return self.add_constraints(lb = other.lb, ub = other.ub,
                                A = other.A, b = other.b, A_eq = other.A_eq, b_eq = other.b_eq,
                                Ls = other.Ls, ys = other.ys, rhos = other.rhos)
                else:
                        raise NotImplementedError

        def __rand__(self, other):
                return self.__and__(other)

1	r""" LinQuadDomain definition
2
3	Philosophically, LinQuad domains consist of those convex domains specified by a combination
4	of linear inequality, linear equality, and quadratic inequality constraints.
5
6	From a code perspective, this is where a dependency on CVXPY is introduced to
7	handle domain properities from within this domain
8
9	"""
10
11	from __future__ import division	5✔
12
13	import numpy as np	5✔
14	import cvxpy as cp	5✔
15	from .domain import TOL, DEFAULT_CVXPY_KWARGS	5✔
16	from .euclidean import EuclideanDomain	5✔
17	from .tensor import TensorProductDomain	5✔
18
19	from ..misc import merge	5✔
20
21	class LinQuadDomain(EuclideanDomain):	5✔
22	r"""A domain specified by a combination of linear (in)equality constraints and convex quadratic constraints
23
24
25	Here we define a domain that is specified in terms of bound constraints,
26	linear inequality constraints, linear equality constraints, and quadratic constraints.
27
28	.. math::
29
30	\mathcal{D} := \left \lbrace
31	\mathbf{x} : \text{lb} \le \mathbf{x} \le \text{ub}, \
32	\mathbf{A} \mathbf{x} \le \mathbf{b}, \
33	\mathbf{A}_{\text{eq}} \mathbf{x} = \mathbf{b}_{\text{eq}}, \
34	\\| \mathbf{L}_i (\mathbf{x} - \mathbf{y}_i)\\|_2 \le \rho_i
35	\right\rbrace \subset \mathbb{R}^m
36
37
38	Parameters
39	----------
40	A: array-like (m,n)
41	Matrix in left-hand side of inequality constraint
42	b: array-like (m,)
43	Vector in right-hand side of the ineqaluty constraint
44	A_eq: array-like (p,n)
45	Matrix in left-hand side of equality constraint
46	b_eq: array-like (p,)
47	Vector in right-hand side of equality constraint
48	lb: array-like (n,)
49	Vector of lower bounds
50	ub: array-like (n,)
51	Vector of upper bounds
52	Ls: list of array-likes (p,m)
53	List of matrices with m columns defining the quadratic constraints
54	ys: list of array-likes (m,)
55	Centers of the quadratic constraints
56	rhos: list of positive floats
57	Radii of quadratic constraints
58	names: list of strings, optional
59	Names for each of the parameters in the space
60	kwargs: dict, optional
61	Additional parameters to be passed to cvxpy Problem.solve()
62	"""
63	def __init__(self, A = None, b = None,	5✔
64	lb = None, ub = None,
65	A_eq = None, b_eq = None,
66	Ls = None, ys = None, rhos = None,
67	names = None, **kwargs):
68
69	self.tol = 1e-6	5✔
70	# Determine dimension of space
71	self._init_dim(lb = lb, ub = ub, A = A, A_eq = A_eq, Ls = Ls)	5✔
72
73	# Start setting default values
74	self._lb = self._init_lb(lb)	5✔
75	self._ub = self._init_ub(ub)	5✔
76	self._A, self._b = self._init_ineq(A, b)	5✔
77	self._A_eq, self._b_eq = self._init_eq(A_eq, b_eq)	5✔
78	self._Ls, self._ys, self._rhos = self._init_quad(Ls, ys, rhos)	5✔
79
80	self._init_names(names)	5✔
81
82
83	self.kwargs = merge(DEFAULT_CVXPY_KWARGS, kwargs)	5✔
84
85	def __str__(self):	5✔
86	ret = "<%s on R^%d" % (self.__class__.__name__, len(self))	5✔
87	if len(self._Ls) > 0:	5✔
88	ret += "; %d quadratic constraints" % (len(self._Ls),)	5✔
89	if self._A.shape[0] > 0:	5✔
90	ret += "; %d linear inequality constraints" % (self._A.shape[0], )	5✔
91	if self._A_eq.shape[0] > 0:	5✔
92	ret += "; %d linear equality constraints" % (self._A_eq.shape[0], )	5✔
93	ret +=">"	5✔
94
95	return ret	5✔
96
97
98	################################################################################
99	# Initialization helpers
100	################################################################################
101	def _init_dim(self, lb = None, ub = None, A = None, A_eq = None, Ls = None):	5✔
102	"""determine the dimension of the space we are working on"""
103	if lb is not None:	5✔
104	if isinstance(lb, (int, float)):	5✔
105	m = 1	5✔
106	else:
107	m = len(lb)	5✔
108	elif ub is not None:	5!
109	if isinstance(ub, (int, float)):	×
UNCOV 110	m = 1	×
111	else:
UNCOV 112	m = len(ub)	×
113	elif A is not None:	5✔
114	m = len(A[0])	5✔
115	elif A_eq is not None:	5!
UNCOV 116	m = len(A_eq[0])	×
117	elif Ls is not None:	5!
118	m = len(Ls[0][0])	5✔
119	else:
UNCOV 120	raise Exception("Could not determine dimension of space")	×
121
122	self._dimension = m	5✔
123
124
125	def _init_lb(self, lb):	5✔
126	if lb is None:	5✔
127	return -np.inf*np.ones(len(self))	5✔
128	else:
129	if isinstance(lb, (int, float)):	5✔
130	lb = [lb]	5✔
131	assert len(lb) == len(self), "Lower bound has wrong dimensions"	5✔
132	return np.array(lb)	5✔
133
134	def _init_ub(self, ub):	5✔
135	if ub is None:	5✔
136	return np.inf*np.ones(len(self))	5✔
137	else:
138	if isinstance(ub, (int, float)):	5✔
139	ub = [ub]	5✔
140	assert len(ub) == len(self), "Upper bound has wrong dimensions"	5✔
141	return np.array(ub)	5✔
142
143	def _init_ineq(self, A, b):	5✔
144	if A is None and b is None:	5✔
145	A = np.zeros((0,len(self)))	5✔
146	b = np.zeros((0,))	5✔
147	elif A is not None and b is not None:	5!
148	A = np.array(A)	5✔
149	b = np.array(b)	5✔
150	if len(b.shape) == 0:	5!
UNCOV 151	b = b.reshape(1)	×
152
153	assert len(b.shape) == 1, "b must have only one dimension"	5✔
154
155	if len(A.shape) == 1 and len(b) == 1:	5!
UNCOV 156	A = A.reshape(1,-1)	×
157
158	assert A.shape[1] == len(self), "A has wrong number of columns"	5✔
159	assert A.shape[0] == b.shape[0], "The number of rows of A and b do not match"	5✔
160	else:
UNCOV 161	raise AssertionError("If using inequality constraints, both A and b must be specified")	×
162	return A, b	5✔
163
164	def _init_eq(self, A_eq, b_eq):	5✔
165	if A_eq is None and b_eq is None:	5✔
166	A_eq = np.zeros((0,len(self)))	5✔
167	b_eq = np.zeros((0,))	5✔
168	elif A_eq is not None and b_eq is not None:	5!
169	A_eq = np.array(A_eq)	5✔
170	b_eq = np.array(b_eq)	5✔
171	if len(b_eq.shape) == 0:	5!
UNCOV 172	b_eq = b_eq.reshape(1)	×
173
174	assert len(b_eq.shape) == 1, "b_eq must have only one dimension"	5✔
175
176	if len(A_eq.shape) == 1 and len(b_eq) == 1:	5✔
177	A_eq = A_eq.reshape(1,-1)	5✔
178
179	assert A_eq.shape[1] == len(self), "A_eq has wrong number of columns"	5✔
180	assert A_eq.shape[0] == b_eq.shape[0], "The number of rows of A_eq and b_eq do not match"	5✔
181	else:
UNCOV 182	raise AssertionError("If using equality constraints, both A_eq and b_eq must be specified")	×
183
184	return A_eq, b_eq	5✔
185
186	def _init_quad(self, Ls, ys, rhos):	5✔
187	if Ls is None and ys is None and rhos is None:	5✔
188	_Ls = []	5✔
189	_ys = []	5✔
190	_rhos = []	5✔
191	elif Ls is not None and ys is not None and rhos is not None:	5!
192	assert len(Ls) == len(ys) == len(rhos), "Length of all quadratic constraints must be the same"	5✔
193
194	_Ls = []	5✔
195	_ys = []	5✔
196	_rhos = []	5✔
197	for L, y, rho in zip(Ls, ys, rhos):	5✔
198	assert len(L[0]) == len(self), "dimension of L doesn't match the domain"	5✔
199	assert len(y) == len(self), "Dimension of center doesn't match the domain"	5✔
200	assert rho > 0, "Radius must be positive"	5✔
201	_Ls.append(np.array(L))	5✔
202	_ys.append(np.array(y))	5✔
203	_rhos.append(rho)	5✔
204	# TODO: If constraint is rank-1, should we implicitly convert to a linear inequality constriant
205	else:
UNCOV 206	raise AssertionError("If providing quadratic constraint, each of Ls, ys, and rhos must be defined")	×
207	return _Ls, _ys, _rhos	5✔
208
209	################################################################################
210	# Simple properties
211	################################################################################
212	def __len__(self): return self._dimension	5✔
213
214	@property	5✔
215	def lb(self): return self._lb	5✔
216
217	@property	5✔
218	def ub(self): return self._ub	5✔
219
220	@property	5✔
221	def A(self): return self._A	5✔
222
223	@property	5✔
224	def b(self): return self._b	5✔
225
226	@property	5✔
227	def A_eq(self): return self._A_eq	5✔
228
229	@property	5✔
230	def b_eq(self): return self._b_eq	5✔
231
232	@property	5✔
233	def Ls(self): return self._Ls	5✔
234
235	@property	5✔
236	def ys(self): return self._ys	5✔
237
238	@property	5✔
239	def rhos(self): return self._rhos	5✔
240
241
242
243
244	################################################################################
245	# Normalization
246	################################################################################
247	def _normalized_domain(self, **kwargs):	5✔
UNCOV 248	names_norm = [name + ' (normalized)' for name in self.names]	×
249
UNCOV 250	return LinQuadDomain(lb = self.lb_norm, ub = self.ub_norm, A = self.A_norm, b = self.b_norm,	×
251	A_eq = self.A_eq_norm, b_eq = self.b_eq_norm, Ls = self.Ls_norm, ys = self.ys_norm, rhos = self.rhos_norm,
252	names = names_norm, **merge(self.kwargs, kwargs))
253
254	def _isinside(self, X, tol = TOL):	5✔
255	return self._isinside_bounds(X, tol = tol) & self._isinside_ineq(X, tol = tol) & self._isinside_eq(X, tol = tol) & self._isinside_quad(X, tol = tol)	5✔
256
257	def _extent(self, x, p):	5✔
258	# Check that direction satisfies equality constraints to a tolerance
259	if self.A_eq.shape[0] == 0 or np.all(np.abs(self.A_eq.dot(p) ) < self.tol):	5!
260	return min(self._extent_bounds(x, p), self._extent_ineq(x, p), self._extent_quad(x, p))	5✔
261	else:
UNCOV 262	return 0.	×
263
264	################################################################################
265	# Convex Solver Functions
266	################################################################################
267
268	def _build_constraints_norm(self, x_norm):	5✔
269	r""" Build the constraints corresponding to the domain given a vector x
270	"""
271	constraints = []	5✔
272
273	# Numerical issues emerge with unbounded constraints
274	I = np.isfinite(self.lb_norm)	5✔
275	if np.sum(I) > 0:	5✔
276	constraints.append( self.lb_norm[I] <= x_norm[I])	5✔
277
278	I = np.isfinite(self.ub_norm)	5✔
279	if np.sum(I) > 0:	5✔
280	constraints.append( x_norm[I] <= self.ub_norm[I])	5✔
281
282	if self.A.shape[0] > 0:	5✔
283	constraints.append( x_norm.__rmatmul__(self.A_norm) <= self.b_norm)	5✔
284	if self.A_eq.shape[0] > 0:	5✔
285	constraints.append( x_norm.__rmatmul__(self.A_eq_norm) == self.b_eq_norm)	5✔
286
287	for L, y, rho in zip(self.Ls_norm, self.ys_norm, self.rhos_norm):	5✔
288	if len(L) > 1:	5✔
289	constraints.append( cp.norm(x_norm.__rmatmul__(L) - L.dot(y)) <= rho )	5✔
290	elif len(L) == 1:	5!
291	constraints.append( cp.norm(L*x_norm - L.dot(y)) <= rho)	5✔
292
293	return constraints	5✔
294
295
296	def _build_constraints(self, x):	5✔
297	r""" Build the constraints corresponding to the domain given a vector x
298	"""
299	constraints = []	5✔
300
301	# Numerical issues emerge with unbounded constraints
302	I = np.isfinite(self.lb)	5✔
303	if np.sum(I) > 0:	5!
304	constraints.append( self.lb[I] <= x[I])	5✔
305
306	I = np.isfinite(self.ub)	5✔
307	if np.sum(I) > 0:	5!
308	constraints.append( x[I] <= self.ub[I])	5✔
309
310	if self.A.shape[0] > 0:	5!
UNCOV 311	constraints.append( x.__rmatmul__(self.A) <= self.b)	×
312	if self.A_eq.shape[0] > 0:	5!
313	constraints.append( x.__rmatmul__(self.A_eq) == self.b_eq)	5✔
314
315	for L, y, rho in zip(self.Ls, self.ys, self.rhos):	5!
316	if len(L) > 1:	×
317	constraints.append( cp.norm(x.__rmatmul__(L) - L.dot(y)) <= rho )	×
318	elif len(L) == 1:	×
UNCOV 319	constraints.append( cp.norm(L*x - L.dot(y)) <= rho)	×
320
321	return constraints	5✔
322
323
324	################################################################################
325	#
326	################################################################################
327
328	def add_constraints(self, A = None, b = None, lb = None, ub = None, A_eq = None, b_eq = None,	5✔
329	Ls = None, ys = None, rhos = None):
330	r"""Add new constraints to the domain
331	"""
332	lb = self._init_lb(lb)	5✔
333	ub = self._init_ub(ub)	5✔
334	A, b = self._init_ineq(A, b)	5✔
335	A_eq, b_eq = self._init_eq(A_eq, b_eq)	5✔
336	Ls, ys, rhos = self._init_quad(Ls, ys, rhos)	5✔
337
338	# Update constraints
339	lb = np.maximum(lb, self.lb)	5✔
340	ub = np.minimum(ub, self.ub)	5✔
341
342	A = np.vstack([self.A, A])	5✔
343	b = np.hstack([self.b, b])	5✔
344
345	A_eq = np.vstack([self.A_eq, A_eq])	5✔
346	b_eq = np.hstack([self.b_eq, b_eq])	5✔
347
348	Ls = self.Ls + Ls	5✔
349	ys = self.ys + ys	5✔
350	rhos = self.rhos + rhos	5✔
351
352	if len(Ls) > 0:	5✔
353	return LinQuadDomain(lb = lb, ub = ub, A = A, b = b, A_eq = A_eq, b_eq = b_eq,	5✔
354	Ls = Ls, ys = ys, rhos = rhos, names = self.names)
355	elif len(b) > 0 or len(b_eq) > 0:	5!
356	from .linineq import LinIneqDomain	5✔
357	return LinIneqDomain(lb = lb, ub = ub, A = A, b = b, A_eq = A_eq, b_eq = b_eq, names = self.names)	5✔
358	else:
359	from .box import BoxDomain	×
UNCOV 360	return BoxDomain(lb = lb, ub = ub, names = self.names)	×
361
362	def __and__(self, other):	5✔
363	if isinstance(other, LinQuadDomain) or (isinstance(other, TensorProductDomain) and other.is_linquad_domain):	5!
364	return self.add_constraints(lb = other.lb, ub = other.ub,	5✔
365	A = other.A, b = other.b, A_eq = other.A_eq, b_eq = other.b_eq,
366	Ls = other.Ls, ys = other.ys, rhos = other.rhos)
367	else:
UNCOV 368	raise NotImplementedError	×
369
370	def __rand__(self, other):	5✔
371	return self.__and__(other)	5✔

jeffrey-hokanson / PSDR / 377

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous