Ejemplo n.º 1
0
 def test_convexify_deg_2_negative_hessian(self):
     f = lambda x: -x**2
     f_hess = np.array([[-2.0]])
     e = Expr(f)
     quad_e = e.convexify(np.zeros((1, 1)), degree=2)
     self.assertIsInstance(quad_e, QuadExpr)
     Q = quad_e.Q
     self.assertTrue(np.allclose(Q, np.zeros((1, 1))))
Ejemplo n.º 2
0
 def test_convexify_deg_2_multi_dim(self):
     x0 = np.array([[5.0], [5.0]])
     f = lambda x: np.vstack((\
         x[0,0]**2 + x[1,0]**2 - 4, \
         -((x[0,0]-1)**2 +(x[1,0]**2-1)**2 - 0.25), \
         -((x[0,0]+1)**2 +(x[1,0]**2-1)**2 - 0.25), \
         -((x[0,0])**2 + 7*(x[1,0]+1-x[0,0]**2/2)**2 - 0.8)))
     e = Expr(f)
     aff_e = e.convexify(x0)
     self.assertTrue(aff_e.A.shape[0] == aff_e.b.shape[0])
Ejemplo n.º 3
0
    def test_convexify_deg_1(self):
        for f, fder, _ in fs:
            e = Expr(f)
            for x in xs:
                y = f(x)
                y_prime = fder(x)

                aff_e = e.convexify(x, degree=1)
                self.assertIsInstance(aff_e, AffExpr)
                A = aff_e.A
                b = aff_e.b
                self.assertTrue(np.allclose(A, fder(x)))
                self.assertTrue(np.allclose(b, f(x) - A.dot(x)))
                self.assertTrue(np.allclose(aff_e.eval(x), f(x)))
Ejemplo n.º 4
0
    def test_convexify_deg_2(self):
        for f, fder, fhess in fs:
            e = Expr(f)
            for x in xs:
                y = f(x)
                y_prime = fder(x)
                y_d_prime = fhess(x)
                y_d_prime = np.maximum(y_d_prime, np.zeros((1, 1)))

                quad_e = e.convexify(x, degree=2)
                self.assertIsInstance(quad_e, QuadExpr)
                Q = np.maximum(quad_e.Q, np.zeros((1, 1)))
                A = quad_e.A
                b = quad_e.b
                self.assertTrue(np.allclose(Q, y_d_prime))
                self.assertTrue(np.allclose(A, \
                    y_prime -np.transpose(x).dot(y_d_prime)))
                self.assertTrue(np.allclose(b, \
                    np.array(0.5*np.transpose(x).dot(y_d_prime)).dot(x) \
                                - y_prime.dot(x) + y))
                self.assertTrue(np.allclose(quad_e.eval(x), y))