示例#1
0
    def test_ast(self): # pylint: disable=too-many-statements
        if sys.platform[:3] == "win":
            return

        t = Variable("t")
        u = Variable("u")
        v = Variable("v")
        w = Variable("w")
        x = VectorVariable(3, "x")
        y = VectorVariable(3, "y")
        z = VectorVariable(3, "z")
        a = VectorVariable((3, 2), "a")

        # print(w >= x)  # TODO: this always prints the vector on the left
        self.assertEqual(str(3*(x + y)*z), "3·(x[:] + y[:])·z[:]")
        nni = 3
        ii = np.tile(np.arange(1, nni+1), a.shape[1:]+(1,)).T
        self.assertEqual(str(w*NomialArray(ii)/nni)[:4], "w·[[")
        self.assertEqual(str(w*NomialArray(ii)/nni)[-4:], "]]/3")
        self.assertEqual(str(NomialArray(ii)*w/nni)[:2], "[[")
        self.assertEqual(str(NomialArray(ii)*w/nni)[-6:], "]]·w/3")
        self.assertEqual(str(w*ii/nni)[:4], "w·[[")
        self.assertEqual(str(w*ii/nni)[-4:], "]]/3")
        self.assertEqual(str(w*(ii/nni))[:4], "w·[[")
        self.assertEqual(str(w*(ii/nni))[-2:], "]]")
        self.assertEqual(str(w >= (x[0]*t + x[1]*u)/v),
                         "w >= (x[0]·t + x[1]·u)/v")
        self.assertEqual(str(x), "x[:]")
        self.assertEqual(str(x*2), "x[:]·2")
        self.assertEqual(str(2*x), "2·x[:]")
        self.assertEqual(str(x + 2), "x[:] + 2")
        self.assertEqual(str(2 + x), "2 + x[:]")
        self.assertEqual(str(x/2), "x[:]/2")
        self.assertEqual(str(2/x), "2/x[:]")
        self.assertEqual(str(x**3), "x[:]³")
        self.assertEqual(str(-x), "-x[:]")
        self.assertEqual(str(x/y/z), "x[:]/y[:]/z[:]")
        self.assertEqual(str(x/(y/z)), "x[:]/(y[:]/z[:])")
        self.assertEqual(str(x >= y), "x[:] >= y[:]")
        self.assertEqual(str(x >= y + z), "x[:] >= y[:] + z[:]")
        self.assertEqual(str(x[:2]), "x[:2]")
        self.assertEqual(str(x[:]), "x[:]")
        self.assertEqual(str(x[1:]), "x[1:]")
        self.assertEqual(str(y * [1, 2, 3]), "y[:]·[1, 2, 3]")
        self.assertEqual(str(x[:2] == (y*[1, 2, 3])[:2]),
                         "x[:2] = (y[:]·[1, 2, 3])[:2]")
        self.assertEqual(str(y + [1, 2, 3]), "y[:] + [1, 2, 3]")
        self.assertEqual(str(x == y + [1, 2, 3]), "x[:] = y[:] + [1, 2, 3]")
        self.assertEqual(str(x >= y + [1, 2, 3]), "x[:] >= y[:] + [1, 2, 3]")
        self.assertEqual(str(a[:, 0]), "a[:,0]")
        self.assertEqual(str(a[2, :]), "a[2,:]")
        g = 1 + 3*a[2, 0]**2
        gstrbefore = str(g)
        g.ast = None
        gstrafter = str(g)
        self.assertEqual(gstrbefore, gstrafter)
示例#2
0
    def test_ast(self):  # pylint: disable=too-many-statements
        t = Variable("t")
        u = Variable("u")
        v = Variable("v")
        w = Variable("w")
        x = VectorVariable(3, "x")
        y = VectorVariable(3, "y")
        z = VectorVariable(3, "z")
        a = VectorVariable((3, 2), "a")

        print(w >= x)
        self.assertEqual(str(3 * (x + y) * z), "3*(x[:] + y[:])*z[:]")
        nni = 3
        ii = np.tile(np.arange(1., nni + 1.), a.shape[1:] + (1, )).T
        self.assertEqual(str(w * NomialArray(ii) / nni)[:4], "w*[[")
        self.assertEqual(str(w * NomialArray(ii) / nni)[-4:], "]]/3")
        self.assertEqual(str(NomialArray(ii) * w / nni)[:2], "[[")
        self.assertEqual(str(NomialArray(ii) * w / nni)[-6:], "]]*w/3")
        self.assertEqual(str(w * ii / nni)[:4], "w*[[")
        self.assertEqual(str(w * ii / nni)[-4:], "]]/3")
        self.assertEqual(str(w * (ii / nni))[:4], "w*[[")
        self.assertEqual(str(w * (ii / nni))[-2:], "]]")
        self.assertEqual(str(w >= (x[0] * t + x[1] * u) / v),
                         "w >= (x[0]*t + x[1]*u)/v")
        self.assertEqual(str(x), "x[:]")
        self.assertEqual(str(x * 2), "x[:]*2")
        self.assertEqual(str(2 * x), "2*x[:]")
        self.assertEqual(str(x + 2), "x[:] + 2")
        self.assertEqual(str(2 + x), "2 + x[:]")
        self.assertEqual(str(x / 2), "x[:]/2")
        self.assertEqual(str(2 / x), "2/x[:]")
        if sys.version_info <= (3, 0):
            self.assertEqual(str(x**3), "x[:]^3")
        self.assertEqual(str(-x), "-x[:]")
        self.assertEqual(str(x / y / z), "x[:]/y[:]/z[:]")
        self.assertEqual(str(x / (y / z)), "x[:]/(y[:]/z[:])")
        self.assertEqual(str(x >= y), "x[:] >= y[:]")
        self.assertEqual(str(x >= y + z), "x[:] >= y[:] + z[:]")
        self.assertEqual(str(x[:2]), "x[:2]")
        self.assertEqual(str(x[:]), "x[:]")
        self.assertEqual(str(x[1:]), "x[1:]")
        self.assertEqual(str(y * [1, 2, 3]), "y[:]*[1, 2, 3]")
        self.assertEqual(str(x[:2] == (y * [1, 2, 3])[:2]),
                         "x[:2] = (y[:]*[1, 2, 3])[:2]")
        self.assertEqual(str(y + [1, 2, 3]), "y[:] + [1, 2, 3]")
        self.assertEqual(str(x == y + [1, 2, 3]), "x[:] = y[:] + [1, 2, 3]")
        self.assertEqual(str(x >= y + [1, 2, 3]), "x[:] >= y[:] + [1, 2, 3]")
        self.assertEqual(str(a[:, 0]), "a[:,0]")
        self.assertEqual(str(a[2, :]), "a[2,:]")
        g = 1 + 3 * a[2, 0]**2
        gstrbefore = str(g)
        g.ast = None
        gstrafter = str(g)
        if sys.version_info <= (3, 0):
            self.assertEqual(gstrbefore, gstrafter)
示例#3
0
    def test_init(self):
        """Test VectorVariable initialization"""
        # test 1
        n = 3
        v = VectorVariable(n, 'v', label='dummy variable')
        self.assertTrue(isinstance(v, NomialArray))
        v_mult = 3*v
        for i in range(n):
            self.assertTrue(isinstance(v[i], PlainVariable))
            self.assertTrue(isinstance(v[i], Monomial))
            # test that operations on Variable cast to Monomial
            self.assertTrue(isinstance(v_mult[i], Monomial))
            self.assertFalse(isinstance(v_mult[i], PlainVariable))

        # test 2
        x = VectorVariable(3, 'x', label='dummy variable')
        x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable')
        x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable')
        x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable')
        x2 = NomialArray([x_0, x_1, x_2])
        self.assertEqual(x, x2)

        # test inspired by issue 137
        N = 20
        x_arr = np.arange(0, 5, 5/N) + 1e-6
        x = VectorVariable(N, 'x', x_arr, 'm', "Beam Location")
示例#4
0
 def test_constraint_gen(self):
     x = VectorVariable(3, 'x', label='dummy variable')
     x_0 = Monomial('x', idx=(0, ), shape=(3, ), label='dummy variable')
     x_1 = Monomial('x', idx=(1, ), shape=(3, ), label='dummy variable')
     x_2 = Monomial('x', idx=(2, ), shape=(3, ), label='dummy variable')
     v = NomialArray([1, 2, 3]).T
     p = [x_0, x_1 / 2, x_2 / 3]
     self.assertEqual((x <= v).as_posyslt1(), p)
示例#5
0
 def test_constraint_gen(self):
     x = VectorVariable(3, 'x', label='dummy variable')
     x_0 = Variable('x', idx=(0, ), shape=(3, ), label='dummy variable')
     x_1 = Variable('x', idx=(1, ), shape=(3, ), label='dummy variable')
     x_2 = Variable('x', idx=(2, ), shape=(3, ), label='dummy variable')
     v = NomialArray([1, 2, 3]).T
     p = [x_0, x_1 / 2, x_2 / 3]
     self.assertEqual(list((x <= v).flathmaps({})), [e.hmap for e in p])
示例#6
0
 def test_constraint_creation_units(self):
     v = VectorVariable(2, "v", "m/s")
     c = (v >= 40*gpkit.units("ft/s"))
     c2 = (v >= np.array([20, 30])*gpkit.units("ft/s"))
     if gpkit.units:
         self.assertTrue(c.right.units)
         self.assertTrue(NomialArray(c2.right).units)
     else:
         self.assertEqual(type(c.right), int)
         self.assertEqual(type(c2.right), np.ndarray)
示例#7
0
 def test_array_mult(self):
     x = VectorVariable(3, 'x', label='dummy variable')
     x_0 = Monomial('x', idx=(0, ), shape=(3, ), label='dummy variable')
     x_1 = Monomial('x', idx=(1, ), shape=(3, ), label='dummy variable')
     x_2 = Monomial('x', idx=(2, ), shape=(3, ), label='dummy variable')
     p = x_0**2 + x_1**2 + x_2**2
     self.assertEqual(x.dot(x), p)
     m = NomialArray([[x_0**2, x_0 * x_1, x_0 * x_2],
                      [x_0 * x_1, x_1**2, x_1 * x_2],
                      [x_0 * x_2, x_1 * x_2, x_2**2]])
     self.assertEqual(x.outer(x), m)
示例#8
0
    def test_init(self):
        """Test VectorVariable initialization"""
        # test 1
        n = 3
        v = VectorVariable(n, 'v', label='dummy variable')
        self.assertTrue(isinstance(v, NomialArray))
        v_mult = 3*v
        for i in range(n):
            self.assertTrue(isinstance(v[i], PlainVariable))
            self.assertTrue(isinstance(v[i], Monomial))
            # test that operations on Variable cast to Monomial
            self.assertTrue(isinstance(v_mult[i], Monomial))
            self.assertFalse(isinstance(v_mult[i], PlainVariable))

        # test 2
        x = VectorVariable(3, 'x', label='dummy variable')
        x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable')
        x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable')
        x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable')
        x2 = NomialArray([x_0, x_1, x_2])
        self.assertEqual(x, x2)

        # test inspired by issue 137
        N = 20
        x_arr = np.arange(0, 5, 5/N) + 1e-6
        x = VectorVariable(N, 'x', x_arr, 'm', "Beam Location")

        with self.assertRaises(ValueError):
            _ = VectorVariable(2, "x", [1, 2, 3])

        with Vectorize(2):
            x = VectorVariable(3, "x", np.array([13, 15, 17]))
            self.assertEqual(x[0, 0].value, 13)
            self.assertEqual(x[1, 0].value, 15)
            self.assertEqual(x[2, 0].value, 17)
            self.assertEqual(x[0, 0].value, x[0, 1].value)
            self.assertEqual(x[1, 0].value, x[1, 1].value)
            self.assertEqual(x[2, 0].value, x[2, 1].value)
示例#9
0
 def test_elementwise_mult(self):
     m = Monomial('m')
     x = VectorVariable(3, 'x', label='dummy variable')
     x_0 = Monomial('x', idx=(0, ), shape=(3, ), label='dummy variable')
     x_1 = Monomial('x', idx=(1, ), shape=(3, ), label='dummy variable')
     x_2 = Monomial('x', idx=(2, ), shape=(3, ), label='dummy variable')
     # multiplication with numbers
     v = NomialArray([2, 2, 3]).T
     p = NomialArray([2 * x_0, 2 * x_1, 3 * x_2]).T
     self.assertEqual(x * v, p)
     # division with numbers
     p2 = NomialArray([x_0 / 2, x_1 / 2, x_2 / 3]).T
     self.assertEqual(x / v, p2)
     # power
     p3 = NomialArray([x_0**2, x_1**2, x_2**2]).T
     self.assertEqual(x**2, p3)
     # multiplication with monomials
     p = NomialArray([m * x_0, m * x_1, m * x_2]).T
     self.assertEqual(x * m, p)
     # division with monomials
     p2 = NomialArray([x_0 / m, x_1 / m, x_2 / m]).T
     self.assertEqual(x / m, p2)
示例#10
0
    def __init__(self,
                 df,
                 ivar,
                 dvars,
                 nobounds=False,
                 err_margin=False,
                 airfoil=False):
        self.airfoil = airfoil
        self.dvars = dvars
        self.ivar = ivar

        K = int(df["K"].iloc[0])
        d = int(df["d"].iloc[0])
        ftype = df["ftype"].iloc[0]
        A = np.array(df[[
            "e%d%d" % (k, i) for k in range(1, K + 1) for i in range(1, d + 1)
        ]])[0].astype(float)
        B = np.array(df[["c%d" % k for k in range(1, K + 1)]])[0].astype(float)

        withvector = False
        withvar = False
        for dv in self.dvars:
            if hasattr(dv, "__len__"):
                withvector = True
                N = len(dv)
            else:
                withvar = True
        if withvector:
            if withvar:
                self.dvars = np.array([
                    dv if isinstance(dv, NomialArray) else [dv] * N
                    for dv in self.dvars
                ]).T
            else:
                self.dvars = np.array(self.dvars).T
        else:
            self.dvars = np.array([self.dvars])
        monos = [
            B * NomialArray([(dv**A[k * d:(k + 1) * d]).prod()
                             for k in range(K)]) for dv in self.dvars
        ]

        if err_margin == "Max":
            maxerr = float(df["max_err"].iloc[0])
            self.mfac = Variable(
                "m_{fac-fit}", 1 + maxerr, "-",
                "max error of " + ivar.descr["label"] + " fit")
        elif err_margin == "RMS":
            rmserr = float(df["rms_err"].iloc[0])
            self.mfac = Variable(
                "m_{fac-fit}", 1 + rmserr, "-",
                "RMS error of " + ivar.descr["label"] + " fit")
        else:
            self.mfac = Variable("m_{fac-fit}", 1.0, "-", "fit factor")

        if ftype == "ISMA":
            # constraint of the form 1 >= c1*u1^exp1*u2^exp2*w^(-alpha) + ....
            alpha = np.array(df[["a%d" % k
                                 for k in range(1, K + 1)]])[0].astype(float)
            lhs = 1
            rhs = NomialArray([(mono / (ivar / self.mfac)**alpha).sum()
                               for mono in monos])
        elif ftype == "SMA":
            # constraint of the form w^alpha >= c1*u1^exp1 + c2*u2^exp2 +....
            alpha = float(df["a1"].iloc[0])
            lhs = (ivar / self.mfac)**alpha
            rhs = NomialArray([mono.sum() for mono in monos])
        elif ftype == "MA":
            # constraint of the form w >= c1*u1^exp1, w >= c2*u2^exp2, ....
            lhs, rhs = (ivar / self.mfac), NomialArray(monos)

        if K == 1:
            # when possible, return an equality constraint
            if withvector:
                cstrt = [(lh == rh) for rh, lh in zip(rhs, lhs)]
            else:
                cstrt = (lhs == rhs)
        else:
            if withvector:
                cstrt = [(lh >= rh) for rh, lh in zip(rhs, lhs)]
            else:
                cstrt = (lhs >= rhs)

        constraints = [cstrt]
        if not hasattr(self.mfac, "__len__"):
            self.mfac = [self.mfac] * len(self.dvars)
        if not hasattr(self.ivar, "__len__"):
            self.ivar = [self.ivar] * len(self.dvars)

        self.bounds = []
        for dvar in self.dvars:
            bds = {}
            for i, v in enumerate(dvar):
                bds[v] = [
                    float(df["lb%d" % (i + 1)].iloc[0]),
                    float(df["ub%d" % (i + 1)].iloc[0])
                ]
            self.bounds.append(bds)

        ConstraintSet.__init__(self, constraints)