def setup_class(self): self.cvx = Variable()**2 self.ccv = Variable()**0.5 self.aff = Variable() self.const = Constant(5) self.unknown_curv = log(Variable()**3) self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown_sign = Parameter()
def solver(A, y, huber_param, w_bounds, y_bounds, w_radi, y_sample_weights, theta, gamma = 0.01): ''' Presently, we perform Huber Regression on our data matrix, with our own specialized way of regularizing the weights, the results of the model fitting. If we currently do not have a huber parameter to use, we will let the method to optimize for one ''' w_radi_sqrt = np.sqrt( w_radi ) #bounds on weights wl = Constant( w_bounds[:, 0] ) wu = Constant( w_bounds[:, 1] ) #bounds on targets yl = Constant( y_bounds[:, 0] ) yu = Constant( y_bounds[:, 1] ) n = A.shape[0] m = A.shape[1] #weight variable w_var = Variable(m) y_var = A.dot(w_var) deviance = y_sample_weights.T * huber(y_var - y, M = huber_param) divergence = square( norm( multiply( w_radi_sqrt, ( w_var - 1.0 ) ) ) ) constraints = [wl <= w_var, w_var <= wu, y_var <= yu, yl <= y_var, divergence <= ( theta ** 2.0 )] cost = (1.0 - gamma)*deviance + gamma*divergence prob = Problem(Minimize(cost), constraints) prob.solve(solver = 'ECOS', abstol = 1e-4, reltol = 1e-3, feastol = 1e-4, max_iters = 1000, verbose = False ) w_sol = np.array( w_var.value ) #this still needs to be done since solver only satisfies constraints #within a tolerance of 1e-4 w_sol = np.clip(w_sol, wl.value, wu.value).ravel() w_sol = np.squeeze(np.asarray(w_sol)) return w_sol, prob.status
def cvxpy_solve_qp(P, q, G=None, h=None, A=None, b=None, initvals=None, solver=None): """ Solve a Quadratic Program defined as: minimize (1/2) * x.T * P * x + q.T * x subject to G * x <= h A * x == b calling a given solver using the CVXPY <http://www.cvxpy.org/> modelling language. Parameters ---------- P : array, shape=(n, n) Primal quadratic cost matrix. q : array, shape=(n,) Primal quadratic cost vector. G : array, shape=(m, n) Linear inequality constraint matrix. h : array, shape=(m,) Linear inequality constraint vector. A : array, shape=(meq, n), optional Linear equality constraint matrix. b : array, shape=(meq,), optional Linear equality constraint vector. initvals : array, shape=(n,), optional Warm-start guess vector (not used). solver : string, optional Solver name in ``cvxpy.installed_solvers()``. Returns ------- x : array, shape=(n,) Solution to the QP, if found, otherwise ``None``. """ if initvals is not None: print("CVXPY: note that warm-start values are ignored by wrapper") n = q.shape[0] x = Variable(n) P = Constant(P) # see http://www.cvxpy.org/en/latest/faq/ objective = Minimize(0.5 * quad_form(x, P) + q * x) constraints = [] if G is not None: constraints.append(G * x <= h) if A is not None: constraints.append(A * x == b) prob = Problem(objective, constraints) prob.solve(solver=solver) x_opt = array(x.value).reshape((n, )) return x_opt
def cvxpy_solve_qp(P, q, G=None, h=None, A=None, b=None, initvals=None, solver=None, verbose=False): """ Solve a Quadratic Program defined as: .. math:: \\begin{split}\\begin{array}{ll} \\mbox{minimize} & \\frac{1}{2} x^T P x + q^T x \\\\ \\mbox{subject to} & G x \\leq h \\\\ & A x = h \\end{array}\\end{split} calling a given solver using the `CVXPY <http://www.cvxpy.org/>`_ modelling language. Parameters ---------- P : array, shape=(n, n) Primal quadratic cost matrix. q : array, shape=(n,) Primal quadratic cost vector. G : array, shape=(m, n) Linear inequality constraint matrix. h : array, shape=(m,) Linear inequality constraint vector. A : array, shape=(meq, n), optional Linear equality constraint matrix. b : array, shape=(meq,), optional Linear equality constraint vector. initvals : array, shape=(n,), optional Warm-start guess vector (not used). solver : string, optional Solver name in ``cvxpy.installed_solvers()``. verbose : bool, optional Set to `True` to print out extra information. Returns ------- x : array, shape=(n,) Solution to the QP, if found, otherwise ``None``. """ if initvals is not None: print("CVXPY: note that warm-start values are ignored by wrapper") n = q.shape[0] x = Variable(n) P = Constant(P) # see http://www.cvxpy.org/en/latest/faq/ objective = Minimize(0.5 * quad_form(x, P) + q * x) constraints = [] if G is not None: constraints.append(G * x <= h) if A is not None: constraints.append(A * x == b) prob = Problem(objective, constraints) prob.solve(solver=solver, verbose=verbose) x_opt = array(x.value).reshape((n,)) return x_opt
def targets_and_priorities( objectives: List[Union[Minimize, Maximize]], priorities, targets, limits=None, off_target: float = 1e-5) -> Union[Minimize, Maximize]: """Combines objectives with penalties within a range between target and limit. Each Minimize objective i has value priorities[i]*objectives[i] when objectives[i] >= targets[i] +infinity when objectives[i] > limits[i] Each Maximize objective i has value priorities[i]*objectives[i] when objectives[i] <= targets[i] +infinity when objectives[i] < limits[i] Args: objectives: A list of Minimize/Maximize objectives. priorities: The weight within the trange. targets: The start (end) of penalty for Minimize (Maximize) limits: The hard end (start) of penalty for Minimize (Maximize) off_target: Penalty outside of target. Returns: A Minimize/Maximize objective. """ num_objs = len(objectives) new_objs: List[Union[Minimize, Maximize]] = [] for i in range(num_objs): obj = objectives[i] sign = 1 if Constant.cast_to_const(priorities[i]).is_nonneg() else -1 off_target *= sign if type(obj) == Minimize: expr = (priorities[i] - off_target) * atoms.pos(obj.args[0] - targets[i]) expr += off_target * obj.args[0] if limits is not None: expr += sign * indicator([obj.args[0] <= limits[i]]) new_objs.append(expr) else: # Maximize expr = (priorities[i] - off_target) * atoms.min_elemwise( obj.args[0], targets[i]) expr += off_target * obj.args[0] if limits is not None: expr += sign * indicator([obj.args[0] >= limits[i]]) new_objs.append(expr) obj_expr = sum(new_objs) if obj_expr.is_convex(): return Minimize(obj_expr) else: return Maximize(obj_expr)
class TestSign(BaseTest): """ Unit tests for the expression/sign class. """ @classmethod def setup_class(self): self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown = Variable() def test_add(self): self.assertEqual((self.pos + self.neg).sign, self.unknown.sign) self.assertEqual((self.neg + self.zero).sign, self.neg.sign) self.assertEqual((self.pos + self.pos).sign, self.pos.sign) self.assertEqual((self.unknown + self.zero).sign, self.unknown.sign) def test_sub(self): self.assertEqual((self.pos - self.neg).sign, self.pos.sign) self.assertEqual((self.neg - self.zero).sign, self.neg.sign) self.assertEqual((self.pos - self.pos).sign, self.unknown.sign) def test_mult(self): self.assertEqual((self.zero * self.pos).sign, self.zero.sign) self.assertEqual((self.unknown * self.pos).sign, self.unknown.sign) self.assertEqual((self.pos * self.neg).sign, self.neg.sign) self.assertEqual((self.pos * self.pos).sign, self.pos.sign) self.assertEqual((self.pos * self.pos).sign, self.pos.sign) self.assertEqual((self.neg * self.neg).sign, self.pos.sign) self.assertEqual((self.zero * self.unknown).sign, self.zero.sign) def test_neg(self): self.assertEqual((-self.zero).sign, self.zero.sign) self.assertEqual((-self.pos).sign, self.neg.sign) # Tests the is_positive and is_negative methods. def test_is_sign(self): assert self.pos.is_positive() assert not self.neg.is_positive() assert not self.unknown.is_positive() assert self.zero.is_positive() assert not self.pos.is_negative() assert self.neg.is_negative() assert not self.unknown.is_negative() assert self.zero.is_negative() assert self.zero.is_zero() assert not self.neg.is_zero() assert not (self.unknown.is_positive() or self.unknown.is_negative())
def targets_and_priorities(objectives, priorities, targets, limits=None, off_target=1e-5): """Combines objectives with penalties within a range between target and limit. Args: objectives: A list of Minimize/Maximize objectives. priorities: The weight within the trange. targets: The start (end) of penalty for Minimize (Maximize) limits: The hard end (start) of penalty for Minimize (Maximize) off_target: Penalty outside of target. Returns: A Minimize/Maximize objective. """ num_objs = len(objectives) new_objs = [] for i in range(num_objs): obj = objectives[i] sign = 1 if Constant(priorities[i]).is_positive() else -1 off_target *= sign if type(obj) == Minimize: expr = (priorities[i] - off_target)*atoms.pos(obj.args[0] - targets[i]) expr += off_target*obj.args[0] if limits is not None: expr += sign*indicator([obj.args[0] <= limits[i]]) new_objs.append(expr) else: # Maximize expr = (priorities[i] - off_target)*atoms.min_elemwise(obj.args[0], targets[i]) expr += off_target*obj.args[0] if limits is not None: expr += sign*indicator([obj.args[0] >= limits[i]]) new_objs.append(expr) obj_expr = sum(new_objs) if obj_expr.is_convex(): return Minimize(obj_expr) else: return Maximize(obj_expr)
class TestCurvature(object): """ Unit tests for the expression/curvature class. """ @classmethod def setup_class(self): self.cvx = Variable()**2 self.ccv = Variable()**0.5 self.aff = Variable() self.const = Constant(5) self.unknown_curv = log(Variable()**3) self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown_sign = Parameter() def test_add(self): assert_equals((self.const + self.cvx).curvature, self.cvx.curvature) assert_equals((self.unknown_curv + self.ccv).curvature, self.unknown_curv.curvature) assert_equals((self.cvx + self.ccv).curvature, self.unknown_curv.curvature) assert_equals((self.cvx + self.cvx).curvature, self.cvx.curvature) assert_equals((self.aff + self.ccv).curvature, self.ccv.curvature) def test_sub(self): assert_equals((self.const - self.cvx).curvature, self.ccv.curvature) assert_equals((self.unknown_curv - self.ccv).curvature, self.unknown_curv.curvature) assert_equals((self.cvx - self.ccv).curvature, self.cvx.curvature) assert_equals((self.cvx - self.cvx).curvature, self.unknown_curv.curvature) assert_equals((self.aff - self.ccv).curvature, self.cvx.curvature) def test_sign_mult(self): assert_equals((self.zero * self.cvx).curvature, self.const.curvature) assert_equals((self.neg * self.cvx).curvature, self.ccv.curvature) assert_equals((self.neg * self.ccv).curvature, self.cvx.curvature) assert_equals((self.neg * self.unknown_curv).curvature, self.unknown_curv.curvature) assert_equals((self.pos * self.aff).curvature, self.aff.curvature) assert_equals((self.pos * self.ccv).curvature, self.ccv.curvature) assert_equals((self.unknown_sign * self.const).curvature, self.const.curvature) assert_equals((self.unknown_sign * self.ccv).curvature, self.unknown_curv.curvature) def test_neg(self): assert_equals((-self.cvx).curvature, self.ccv.curvature) assert_equals((-self.aff).curvature, self.aff.curvature) # Tests the is_affine, is_convex, and is_concave methods def test_is_curvature(self): assert self.const.is_affine() assert self.aff.is_affine() assert not self.cvx.is_affine() assert not self.ccv.is_affine() assert not self.unknown_curv.is_affine() assert self.const.is_convex() assert self.aff.is_convex() assert self.cvx.is_convex() assert not self.ccv.is_convex() assert not self.unknown_curv.is_convex() assert self.const.is_concave() assert self.aff.is_concave() assert not self.cvx.is_concave() assert self.ccv.is_concave() assert not self.unknown_curv.is_concave()
def setup_class(self): self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown = Variable()
class TestCurvature(unittest.TestCase): """ Unit tests for the expression/curvature class. """ def setUp(self): self.cvx = Variable()**2 self.ccv = Variable()**0.5 self.aff = Variable() self.const = Constant(5) self.unknown_curv = log(Variable()**3) self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown_sign = self.pos + self.neg def test_add(self): self.assertEqual((self.const + self.cvx).curvature, self.cvx.curvature) self.assertEqual((self.unknown_curv + self.ccv).curvature, UNKNOWN) self.assertEqual((self.cvx + self.ccv).curvature, UNKNOWN) self.assertEqual((self.cvx + self.cvx).curvature, self.cvx.curvature) self.assertEqual((self.aff + self.ccv).curvature, self.ccv.curvature) def test_sub(self): self.assertEqual((self.const - self.cvx).curvature, self.ccv.curvature) self.assertEqual((self.unknown_curv - self.ccv).curvature, UNKNOWN) self.assertEqual((self.cvx - self.ccv).curvature, self.cvx.curvature) self.assertEqual((self.cvx - self.cvx).curvature, UNKNOWN) self.assertEqual((self.aff - self.ccv).curvature, self.cvx.curvature) def test_sign_mult(self): self.assertEqual((self.zero * self.cvx).curvature, self.aff.curvature) self.assertEqual((self.neg * self.cvx).curvature, self.ccv.curvature) self.assertEqual((self.neg * self.ccv).curvature, self.cvx.curvature) self.assertEqual((self.neg * self.unknown_curv).curvature, QUASILINEAR) self.assertEqual((self.pos * self.aff).curvature, self.aff.curvature) self.assertEqual((self.pos * self.ccv).curvature, self.ccv.curvature) self.assertEqual((self.unknown_sign * self.const).curvature, self.const.curvature) self.assertEqual((self.unknown_sign * self.ccv).curvature, UNKNOWN) def test_neg(self): self.assertEqual((-self.cvx).curvature, self.ccv.curvature) self.assertEqual((-self.aff).curvature, self.aff.curvature) # Tests the is_affine, is_convex, and is_concave methods def test_is_curvature(self): assert self.const.is_affine() assert self.aff.is_affine() assert not self.cvx.is_affine() assert not self.ccv.is_affine() assert not self.unknown_curv.is_affine() assert self.const.is_convex() assert self.aff.is_convex() assert self.cvx.is_convex() assert not self.ccv.is_convex() assert not self.unknown_curv.is_convex() assert self.const.is_concave() assert self.aff.is_concave() assert not self.cvx.is_concave() assert self.ccv.is_concave() assert not self.unknown_curv.is_concave()
def setUpClass(self) -> None: self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown = Variable()
class TestCurvature(object): """ Unit tests for the expression/curvature class. """ @classmethod def setup_class(self): self.cvx = Variable()**2 self.ccv = Variable()**0.5 self.aff = Variable() self.const = Constant(5) self.unknown_curv = log(Variable()**3) self.pos = Constant(1) self.neg = Constant(-1) self.zero = Constant(0) self.unknown_sign = Parameter() def test_add(self): assert_equals( (self.const + self.cvx).curvature, self.cvx.curvature) assert_equals( (self.unknown_curv + self.ccv).curvature, self.unknown_curv.curvature) assert_equals( (self.cvx + self.ccv).curvature, self.unknown_curv.curvature) assert_equals( (self.cvx + self.cvx).curvature, self.cvx.curvature) assert_equals( (self.aff + self.ccv).curvature, self.ccv.curvature) def test_sub(self): assert_equals( (self.const - self.cvx).curvature, self.ccv.curvature) assert_equals( (self.unknown_curv - self.ccv).curvature, self.unknown_curv.curvature) assert_equals( (self.cvx - self.ccv).curvature, self.cvx.curvature) assert_equals( (self.cvx - self.cvx).curvature, self.unknown_curv.curvature) assert_equals( (self.aff - self.ccv).curvature, self.cvx.curvature) def test_sign_mult(self): assert_equals( (self.zero* self.cvx).curvature, self.const.curvature) assert_equals( (self.neg*self.cvx).curvature, self.ccv.curvature) assert_equals( (self.neg*self.ccv).curvature, self.cvx.curvature) assert_equals( (self.neg*self.unknown_curv).curvature, self.unknown_curv.curvature) assert_equals( (self.pos*self.aff).curvature, self.aff.curvature) assert_equals( (self.pos*self.ccv).curvature, self.ccv.curvature) assert_equals( (self.unknown_sign*self.const).curvature, self.const.curvature) assert_equals( (self.unknown_sign*self.ccv).curvature, self.unknown_curv.curvature) def test_neg(self): assert_equals( (-self.cvx).curvature, self.ccv.curvature) assert_equals( (-self.aff).curvature, self.aff.curvature) # Tests the is_affine, is_convex, and is_concave methods def test_is_curvature(self): assert self.const.is_affine() assert self.aff.is_affine() assert not self.cvx.is_affine() assert not self.ccv.is_affine() assert not self.unknown_curv.is_affine() assert self.const.is_convex() assert self.aff.is_convex() assert self.cvx.is_convex() assert not self.ccv.is_convex() assert not self.unknown_curv.is_convex() assert self.const.is_concave() assert self.aff.is_concave() assert not self.cvx.is_concave() assert self.ccv.is_concave() assert not self.unknown_curv.is_concave()
def gen_matrices(x_in, y_in, x_out, y_out, dx, dy, loworder=False): x_center = np.mean(x_in) y_center = np.mean(y_in) n_in = len(x_in) n_out = len(x_out) print("Size of the problem is " + str(n_in + n_out)) deltax_in_in = x_in[..., np.newaxis] - x_in[np.newaxis, ...] # should be x-x' deltax_out_in = x_out[..., np.newaxis] - x_in[np.newaxis, ...] # should be x-x' deltay_in_in = y_in[..., np.newaxis] - y_in[np.newaxis, ...] # y - y' deltay_out_in = y_out[..., np.newaxis] - y_in[np.newaxis, ...] # y - y' l2_in_plus_in_plus = (np.array( [deltax_in_in * dx - dx / 2.0, deltay_in_in * dy - dy / 2.0])**2).sum(axis=0)**0.5 l2_in_plus_in_minus = (np.array( [deltax_in_in * dx - dx / 2.0, deltay_in_in * dy + dy / 2.0])**2).sum(axis=0)**0.5 l2_in_minus_in_plus = (np.array( [deltax_in_in * dx + dx / 2.0, deltay_in_in * dy - dy / 2.0])**2).sum(axis=0)**0.5 l2_in_minus_in_minus = (np.array( [deltax_in_in * dx + dx / 2.0, deltay_in_in * dy + dy / 2.0])**2).sum(axis=0)**0.5 l2_out_plus_in_plus = (np.array( [deltax_out_in * dx - dx / 2.0, deltay_out_in * dy - dy / 2.0])**2).sum(axis=0)**0.5 l2_out_plus_in_minus = (np.array( [deltax_out_in * dx - dx / 2.0, deltay_out_in * dy + dy / 2.0])**2).sum(axis=0)**0.5 l2_out_minus_in_plus = (np.array( [deltax_out_in * dx + dx / 2.0, deltay_out_in * dy - dy / 2.0])**2).sum(axis=0)**0.5 l2_out_minus_in_minus = (np.array( [deltax_out_in * dx + dx / 2.0, deltay_out_in * dy + dy / 2.0])**2).sum(axis=0)**0.5 x_adjacency = sparse.csr_matrix((deltax_in_in == -1) * (deltay_in_in == 0) * -1 + (deltax_in_in == 1) * (deltay_in_in == 0) * 1) y_adjacency = sparse.csr_matrix((deltay_in_in == -1) * (deltax_in_in == 0) * -1 + (deltay_in_in == 1) * (deltax_in_in == 0) * 1) A_in_in_x = fxx(deltax_in_in * dx - dx / 2., deltay_in_in * dy - dy / 2.0, l2_in_plus_in_plus) - \ fxx(deltax_in_in * dx - dx / 2., deltay_in_in * dy + dy / 2.0, l2_in_plus_in_minus) - \ fxx(deltax_in_in * dx + dx / 2., deltay_in_in * dy - dy / 2.0, l2_in_minus_in_plus) + \ fxx(deltax_in_in * dx + dx / 2., deltay_in_in * dy + dy / 2.0, l2_in_minus_in_minus) A_out_in_x = fxx(deltax_out_in * dx - dx / 2., deltay_out_in * dy - dy / 2.0, l2_out_plus_in_plus) - \ fxx(deltax_out_in * dx - dx / 2., deltay_out_in * dy + dy / 2.0, l2_out_plus_in_minus) - \ fxx(deltax_out_in * dx + dx / 2., deltay_out_in * dy - dy / 2.0, l2_out_minus_in_plus) + \ fxx(deltax_out_in * dx + dx / 2., deltay_out_in * dy + dy / 2.0, l2_out_minus_in_minus) D_in_in_x = fxy(deltax_in_in * dx - dx / 2., deltay_in_in * dy - dy / 2.0, l2_in_plus_in_plus) - \ fxy(deltax_in_in * dx - dx / 2., deltay_in_in * dy + dy / 2.0, l2_in_plus_in_minus) - \ fxy(deltax_in_in * dx + dx / 2., deltay_in_in * dy - dy / 2.0, l2_in_minus_in_plus) + \ fxy(deltax_in_in * dx + dx / 2., deltay_in_in * dy + dy / 2.0, l2_in_minus_in_minus) D_out_in_x = fxy(deltax_out_in * dx - dx / 2., deltay_out_in * dy - dy / 2.0, l2_out_plus_in_plus) - \ fxy(deltax_out_in * dx - dx / 2., deltay_out_in * dy + dy / 2.0, l2_out_plus_in_minus) - \ fxy(deltax_out_in * dx + dx / 2., deltay_out_in * dy - dy / 2.0, l2_out_minus_in_plus) + \ fxy(deltax_out_in * dx + dx / 2., deltay_out_in * dy + dy / 2.0, l2_out_minus_in_minus) # u_y measurements A_in_in_y = fxx(deltay_in_in * dy - dy / 2.0, deltax_in_in * dx - dx / 2., l2_in_plus_in_plus) - \ fxx(deltay_in_in * dy + dy / 2.0, deltax_in_in * dx - dx / 2., l2_in_plus_in_minus) - \ fxx(deltay_in_in * dy - dy / 2.0, deltax_in_in * dx + dx / 2., l2_in_minus_in_plus) + \ fxx(deltay_in_in * dy + dy / 2.0, deltax_in_in * dx + dx / 2., l2_in_minus_in_minus) A_out_in_y = fxx(deltay_out_in * dy - dy / 2.0, deltax_out_in * dx - dx / 2., l2_out_plus_in_plus) - \ fxx(deltay_out_in * dy + dy / 2.0, deltax_out_in * dx - dx / 2., l2_out_plus_in_minus) - \ fxx(deltay_out_in * dy - dy / 2.0, deltax_out_in * dx + dx / 2., l2_out_minus_in_plus) + \ fxx(deltay_out_in * dy + dy / 2.0, deltax_out_in * dx + dx / 2., l2_out_minus_in_minus) D_in_in_y = fxy(deltay_in_in * dy - dy / 2.0, deltax_in_in * dx - dx / 2., l2_in_plus_in_plus) - \ fxy(deltay_in_in * dy + dy / 2.0, deltax_in_in * dx - dx / 2., l2_in_plus_in_minus) - \ fxy(deltay_in_in * dy - dy / 2.0, deltax_in_in * dx + dx / 2., l2_in_minus_in_plus) + \ fxy(deltay_in_in * dy + dy / 2.0, deltax_in_in * dx + dx / 2., l2_in_minus_in_minus) D_out_in_y = fxy(deltay_out_in * dy - dy / 2.0, deltax_out_in * dx - dx / 2., l2_out_plus_in_plus) - \ fxy(deltay_out_in * dy + dy / 2.0, deltax_out_in * dx - dx / 2., l2_out_plus_in_minus) - \ fxy(deltay_out_in * dy - dy / 2.0, deltax_out_in * dx + dx / 2., l2_out_minus_in_plus) + \ fxy(deltay_out_in * dy + dy / 2.0, deltax_out_in * dx + dx / 2., l2_out_minus_in_minus) if not loworder: B_in_in_x = x_in[..., np.newaxis] * A_in_in_x - fxxx(deltax_in_in - dx / 2., deltay_in_in - dy / 2.0, l2_in_plus_in_plus) + \ fxxx(deltax_in_in - dx / 2., deltay_in_in + dy / 2.0, l2_in_plus_in_minus) + \ fxxx(deltax_in_in + dx / 2., deltay_in_in - dy / 2.0, l2_in_minus_in_plus) - \ fxxx(deltax_in_in + dx / 2., deltay_in_in + dy / 2.0, l2_in_minus_in_minus) B_out_in_x = x_out[..., np.newaxis] * A_out_in_x - fxxx(deltax_out_in - dx / 2., deltay_out_in - dy / 2.0, l2_out_plus_in_plus) + \ fxxx(deltax_out_in - dx / 2., deltay_out_in + dy / 2.0, l2_out_plus_in_minus) + \ fxxx(deltax_out_in + dx / 2., deltay_out_in - dy / 2.0, l2_out_minus_in_plus) - \ fxxx(deltax_out_in + dx / 2., deltay_out_in + dy / 2.0, l2_out_minus_in_minus) C_in_in_x = y_in[..., np.newaxis] * A_in_in_x - fxxy(deltax_in_in - dx / 2., deltay_in_in - dy / 2.0, l2_in_plus_in_plus) + \ fxxy(deltax_in_in - dx / 2., deltay_in_in + dy / 2.0, l2_in_plus_in_minus) + \ fxxy(deltax_in_in + dx / 2., deltay_in_in - dy / 2.0, l2_in_minus_in_plus) - \ fxxy(deltax_in_in + dx / 2., deltay_in_in + dy / 2.0, l2_in_minus_in_minus) C_out_in_x = y_out[..., np.newaxis] * A_out_in_x - fxxy(deltax_out_in - dx / 2., deltay_out_in - dy / 2.0, l2_out_plus_in_plus) + \ fxxy(deltax_out_in - dx / 2., deltay_out_in + dy / 2.0, l2_out_plus_in_minus) + \ fxxy(deltax_out_in + dx / 2., deltay_out_in - dy / 2.0, l2_out_minus_in_plus) - \ fxxy(deltax_out_in + dx / 2., deltay_out_in + dy / 2.0, l2_out_minus_in_minus) E_in_in_x = x_in[..., np.newaxis] * D_in_in_x - fxyx(deltax_in_in - dx / 2., deltay_in_in - dy / 2.0, l2_in_plus_in_plus) + \ fxyx(deltax_in_in - dx / 2., deltay_in_in + dy / 2.0, l2_in_plus_in_minus) + \ fxyx(deltax_in_in + dx / 2., deltay_in_in - dy / 2.0, l2_in_minus_in_plus) - \ fxyx(deltax_in_in + dx / 2., deltay_in_in + dy / 2.0, l2_in_minus_in_minus) E_out_in_x = x_out[..., np.newaxis] * D_out_in_x - fxyx(deltax_out_in - dx / 2., deltay_out_in - dy / 2.0, l2_out_plus_in_plus) + \ fxyx(deltax_out_in - dx / 2., deltay_out_in + dy / 2.0, l2_out_plus_in_minus) + \ fxyx(deltax_out_in + dx / 2., deltay_out_in - dy / 2.0, l2_out_minus_in_plus) - \ fxyx(deltax_out_in + dx / 2., deltay_out_in + dy / 2.0, l2_out_minus_in_minus) F_in_in_x = y_in[..., np.newaxis] * D_in_in_x - fxyx(deltax_in_in - dx / 2., deltay_in_in - dy / 2.0, l2_in_plus_in_plus) + \ fxyx(deltax_in_in - dx / 2., deltay_in_in + dy / 2.0, l2_in_plus_in_minus) + \ fxyx(deltax_in_in + dx / 2., deltay_in_in - dy / 2.0, l2_in_minus_in_plus) - \ fxyx(deltax_in_in + dx / 2., deltay_in_in + dy / 2.0, l2_in_minus_in_minus) F_out_in_x = y_out[..., np.newaxis] * D_out_in_x - fxyx(deltax_out_in - dx / 2., deltay_out_in - dy / 2.0, l2_out_plus_in_plus) + \ fxyx(deltax_out_in - dx / 2., deltay_out_in + dy / 2.0, l2_out_plus_in_minus) + \ fxyx(deltax_out_in + dx / 2., deltay_out_in - dy / 2.0, l2_out_minus_in_plus) - \ fxyx(deltax_out_in + dx / 2., deltay_out_in + dy / 2.0, l2_out_minus_in_minus) B_in_in_y = y_in[..., np.newaxis] * A_in_in_y - fxxx(deltay_in_in - dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_plus) + \ fxxx(deltay_in_in + dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_minus) + \ fxxx(deltay_in_in - dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_plus) - \ fxxx(deltay_in_in + dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_minus) B_out_in_y = y_out[..., np.newaxis] * A_out_in_y - fxxx(deltay_out_in - dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_plus) + \ fxxx(deltay_out_in + dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_minus) + \ fxxx(deltay_out_in - dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_plus) - \ fxxx(deltay_out_in + dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_minus) C_in_in_y = x_in[..., np.newaxis] * A_in_in_y - fxxy(deltay_in_in - dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_plus) + \ fxxy(deltay_in_in + dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_minus) + \ fxxy(deltay_in_in - dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_plus) - \ fxxy(deltay_in_in + dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_minus) C_out_in_y = x_out[..., np.newaxis] * A_out_in_y - fxxy(deltay_out_in - dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_plus) + \ fxxy(deltay_out_in + dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_minus) + \ fxxy(deltay_out_in - dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_plus) - \ fxxy(deltay_out_in + dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_minus) E_in_in_y = y_in[..., np.newaxis] * D_in_in_y - fxyx(deltay_in_in - dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_plus) + \ fxyx(deltay_in_in + dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_minus) + \ fxyx(deltay_in_in - dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_plus) - \ fxyx(deltay_in_in + dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_minus) E_out_in_y = y_out[..., np.newaxis] * D_out_in_y - fxyx(deltay_out_in - dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_plus) + \ fxyx(deltay_out_in + dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_minus) + \ fxyx(deltay_out_in - dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_plus) - \ fxyx(deltay_out_in + dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_minus) F_in_in_y = x_in[..., np.newaxis] * D_in_in_y - fxyx(deltay_in_in - dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_plus) + \ fxyx(deltay_in_in + dy / 2.0, deltax_in_in - dx / 2., l2_in_plus_in_minus) + \ fxyx(deltay_in_in - dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_plus) - \ fxyx(deltay_in_in + dy / 2.0, deltax_in_in + dx / 2., l2_in_minus_in_minus) F_out_in_y = x_out[..., np.newaxis] * D_out_in_y - fxyx(deltay_out_in - dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_plus) + \ fxyx(deltay_out_in + dy / 2.0, deltax_out_in - dx / 2., l2_out_plus_in_minus) + \ fxyx(deltay_out_in - dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_plus) - \ fxyx(deltay_out_in + dy / 2.0, deltax_out_in + dx / 2., l2_out_minus_in_minus) G_in_in_xx = A_in_in_x + B_in_in_x + C_in_in_x G_in_in_xy = D_in_in_x + E_in_in_x + F_in_in_x G_out_in_xx = (A_out_in_x + B_out_in_x + C_out_in_x) G_out_in_xy = (D_out_in_x + E_out_in_x + F_out_in_x) G_in_in_yy = A_in_in_y + B_in_in_y + C_in_in_y G_in_in_yx = D_in_in_y + E_in_in_y + F_in_in_y G_out_in_yy = (A_out_in_y + B_out_in_y + C_out_in_y) G_out_in_yx = (D_out_in_y + E_out_in_y + F_out_in_y) else: G_in_in_xx = A_in_in_x G_in_in_xy = D_in_in_x G_out_in_xx = A_out_in_x G_out_in_xy = D_out_in_x G_in_in_yy = A_in_in_y G_in_in_yx = D_in_in_y G_out_in_yy = A_out_in_y G_out_in_yx = D_out_in_y Dx = sparse.csr_matrix((deltax_in_in == 0) * (deltay_in_in == 0) * -1 + (deltax_in_in == 1) * (deltay_in_in == 0) * 1) rowsums = np.squeeze(np.asarray((Dx.sum(axis=1) != 0))) Dx[rowsums, :] = 0 Dx.eliminate_zeros() Dx = Constant(Dx) Dy = sparse.csr_matrix((deltay_in_in == 0) * (deltax_in_in == 0) * -1 + (deltay_in_in == 1) * (deltax_in_in == 0) * 1) rowsums = np.squeeze(np.asarray((Dy.sum(axis=1) != 0))) Dy[rowsums, :] = 0 Dy.eliminate_zeros() Dy = Constant(Dy) return G_in_in_xx, G_in_in_xy, G_out_in_xx, G_out_in_xy, G_in_in_yy, G_in_in_yx, G_out_in_yy, G_out_in_yx, Dx, Dy