コード例 #1
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def gycall(self, dae):
        self.pll_gycall(dae)
        self.outer_gycall(dae)
        self.current_gycall(dae)

        dae.add_jac(Gy, cos(dae.y[self.a] - dae.y[self.adq]), self.vd, self.v)
        dae.add_jac(Gy, - mul(dae.y[self.v], sin(dae.y[self.a] - dae.y[self.adq])), self.vd, self.a)
        dae.add_jac(Gy, mul(dae.y[self.v], sin(dae.y[self.a] - dae.y[self.adq])), self.vd, self.adq)
        dae.add_jac(Gy, - sin(dae.y[self.a] - dae.y[self.adq]), self.vq, self.v)
        dae.add_jac(Gy, - mul(dae.y[self.v], cos(dae.y[self.a] - dae.y[self.adq])), self.vq, self.a)
        dae.add_jac(Gy, mul(dae.y[self.v], cos(dae.y[self.a] - dae.y[self.adq])), self.vq, self.adq)
        dae.add_jac(Gy, dae.x[self.Iq], self.p, self.vq)
        dae.add_jac(Gy, dae.x[self.Id], self.p, self.vd)
        dae.add_jac(Gy, - dae.x[self.Id], self.q, self.vq)
        dae.add_jac(Gy, dae.x[self.Iq], self.q, self.vd)
コード例 #2
0
ファイル: probbounds.py プロジェクト: zhengfangwu/cvxopt
    def makefig1():
        pylab.figure(1, facecolor='w', figsize=(6, 6))
        pylab.plot(V[0, :].T, V[1, :].T, 'b-')
        nopts = 1000
        angles = matrix([a * 2.0 * pi / nopts for a in range(nopts)],
                        (1, nopts))
        circle = matrix(0.0, (2, nopts))
        circle[0, :], circle[1, :] = cos(angles), sin(angles)
        for k in range(len(C)):
            c = C[k]
            pylab.plot([c[0]], [c[1]], 'ow')
            pylab.text(c[0], c[1], "s%d" % k)
            pylab.plot(c[0] + circle[0, :].T, c[1] + circle[1, :].T, 'g:')
            if k >= 1:
                v = V[:, k - 1]
                if k == 1:
                    dir = 0.5 * (C[k] + C[-1]) - v
                else:
                    dir = 0.5 * (C[k] + C[k - 1]) - v
                pylab.plot([v[0], v[0] + 5 * dir[0]],
                           [v[1], v[1] + 5 * dir[1]], 'b-')
        ellipse = +circle
        blas.trsm(L, ellipse, transA='T')
        pylab.plot(xc[0] + ellipse[0, :].T, xc[1] + ellipse[1, :].T, 'r-')
        for Xk in X:
            pylab.plot([Xk[0]], [Xk[1]], 'ro')

        pylab.axis([-5, 5, -5, 5])
        pylab.title('Geometrical interpretation of Chebyshev bound (fig. 7.7)')
        pylab.axis('off')
コード例 #3
0
    def gcall(self, dae):
        nzeros = [0] * self.n
        v = mul(self.u, dae.y[self.v])
        vd = dae.y[self.vd]
        vq = dae.y[self.vq]
        Id = dae.y[self.Id]
        Iq = dae.y[self.Iq]
        self.ss = sin(dae.x[self.delta] - dae.y[self.a])
        self.cc = cos(dae.x[self.delta] - dae.y[self.a])

        dae.g -= spmatrix(dae.y[self.p], self.a, nzeros, (dae.m, 1), 'd')
        dae.g -= spmatrix(dae.y[self.q], self.v, nzeros, (dae.m, 1), 'd')
        dae.g -= spmatrix(vd - mul(v, self.ss), self.vd, nzeros, (dae.m, 1),
                          'd')  # note d(vd)/d(delta)
        dae.g -= spmatrix(vq - mul(v, self.cc), self.vq, nzeros, (dae.m, 1),
                          'd')  # note d(vq)/d(delta)
        dae.g += spmatrix(
            mul(vd, Id) + mul(vq, Iq) - dae.y[self.p], self.p, nzeros,
            (dae.m, 1), 'd')
        dae.g += spmatrix(
            mul(vq, Id) - mul(vd, Iq) - dae.y[self.q], self.q, nzeros,
            (dae.m, 1), 'd')
        dae.g += spmatrix(dae.y[self.pm] - self.pm0, self.pm, nzeros,
                          (dae.m, 1), 'd')
        dae.g += spmatrix(dae.y[self.vf] - self.vf0, self.vf, nzeros,
                          (dae.m, 1), 'd')
コード例 #4
0
ファイル: probbounds.py プロジェクト: cvxopt/cvxopt
 def makefig1():
     pylab.figure(1, facecolor='w', figsize=(6,6))
     pylab.plot(V[0,:].T, V[1,:].T, 'b-')
     nopts = 1000
     angles = matrix( [a*2.0*pi/nopts for a in range(nopts) ], 
         (1,nopts) )
     circle = matrix(0.0, (2,nopts))
     circle[0,:], circle[1,:] = cos(angles), sin(angles)
     for k in range(len(C)):
         c = C[k]
         pylab.plot([c[0]], [c[1]], 'og')
         pylab.text(c[0], c[1], "s%d" %k)
         pylab.plot(c[0] + circle[0,:].T, c[1]+circle[1,:].T, 'g:')
         if k >= 1:
             v = V[:,k-1]
             if k==1: 
                 dir = 0.5 * (C[k] + C[-1]) - v
             else: 
                 dir = 0.5 * (C[k] + C[k-1]) - v
             pylab.plot([v[0], v[0] + 5*dir[0]], 
                 [v[1], v[1] + 5*dir[1]], 'b-')
     ellipse = +circle
     blas.trsm(L, ellipse, transA='T')
     pylab.plot(xc[0] + ellipse[0,:].T, xc[1]+ellipse[1,:].T, 'r-')
     for Xk in X: 
         pylab.plot([Xk[0]], [Xk[1]], 'ro')
 
     pylab.axis([-5, 5, -5, 5])
     pylab.title('Geometrical interpretation of Chebyshev bound (fig. 7.7)')
     pylab.axis('off')
コード例 #5
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def gycall(self, dae):
        self.speed_gycall(dae)
        self.voltage_gycall(dae)
        self.current_gycall(dae)

        dae.add_jac(Gy, dae.x[self.Iq], self.p, self.vq)
        dae.add_jac(Gy, dae.x[self.Id], self.p, self.vd)
        dae.add_jac(Gy, - dae.x[self.Id], self.q, self.vq)
        dae.add_jac(Gy, dae.x[self.Iq], self.q, self.vd)
        dae.add_jac(Gy, - mul(self.u, dae.y[self.v], sin(dae.y[self.a] - dae.x[self.adq])), self.vd, self.a)
        dae.add_jac(Gy, mul(self.u, cos(dae.y[self.a] - dae.x[self.adq])), self.vd, self.v)
        dae.add_jac(Gy, - mul(self.u, sin(dae.y[self.a] - dae.x[self.adq])), self.vq, self.v)
        dae.add_jac(Gy, - mul(self.u, dae.y[self.v], cos(dae.y[self.a] - dae.x[self.adq])), self.vq, self.a)
        dae.add_jac(Gy, mul(self.u, (dae.y[self.v1] - dae.y[self.v2])**-2, mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v1, self.v2)
        dae.add_jac(Gy, - mul(self.u, (dae.y[self.v1] - dae.y[self.v2])**-2, mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v1, self.v1)
        dae.add_jac(Gy, - mul(self.u, (dae.y[self.v1] - dae.y[self.v2])**-2, mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v2, self.v2)
        dae.add_jac(Gy, mul(self.u, (dae.y[self.v1] - dae.y[self.v2])**-2, mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v2, self.v1)
コード例 #6
0
ファイル: windturbine.py プロジェクト: mzy2240/andes
 def gycall(self, dae):
     dae.add_jac(Gy, mul(self.xmu, 1 - dae.x[self.omega_m]), self.vrd,
                 self.isq)
     dae.add_jac(Gy, -mul(self.xmu, 1 - dae.x[self.omega_m]), self.vrq,
                 self.isd)
     dae.add_jac(Gy, -sin(dae.y[self.a]), self.vsd, self.v)
     dae.add_jac(Gy, -mul(dae.y[self.v], cos(dae.y[self.a])), self.vsd,
                 self.a)
     dae.add_jac(Gy, cos(dae.y[self.a]), self.vsq, self.v)
     dae.add_jac(Gy, -mul(dae.y[self.v], sin(dae.y[self.a])), self.vsq,
                 self.a)
     dae.add_jac(
         Gy,
         mul(0.5, self.ngen, pi, self.rho, (self.R)**2, (self.Vwn)**3,
             div(1, self.mva_mega), (dae.x[self.vw])**3), self.pw, self.cp)
     dae.add_jac(
         Gy,
         mul(-25.52, (dae.y[self.ilamb])**-2,
             exp(mul(-12.5, div(1, dae.y[self.ilamb])))) + mul(
                 12.5, (dae.y[self.ilamb])**-2,
                 -1.1 + mul(25.52, div(1, dae.y[self.ilamb])) +
                 mul(-0.088, dae.x[self.theta_p]),
                 exp(mul(-12.5, div(1, dae.y[self.ilamb])))), self.cp,
         self.ilamb)
     dae.add_jac(
         Gy,
         mul((dae.y[self.lamb] + mul(0.08, dae.x[self.theta_p]))**-2,
             (div(1, dae.y[self.lamb] + mul(0.08, dae.x[self.theta_p])) +
              mul(-0.035, div(1, 1 + (dae.x[self.theta_p])**3)))**-2),
         self.ilamb, self.lamb)
     dae.add_jac(Gy, -mul(dae.y[self.isd], self.u0), self.a, self.vsd)
     dae.add_jac(Gy, -mul(dae.x[self.irq], self.u0), self.a, self.vrq)
     dae.add_jac(Gy, -mul(self.u0, dae.y[self.vsq]), self.a, self.isq)
     dae.add_jac(Gy, -mul(dae.x[self.ird], self.u0), self.a, self.vrd)
     dae.add_jac(Gy, -mul(dae.y[self.isq], self.u0), self.a, self.vsq)
     dae.add_jac(Gy, -mul(self.u0, dae.y[self.vsd]), self.a, self.isd)
     dae.add_jac(
         Gy,
         mul(
             self.u0,
             mul(2, dae.y[self.v], div(1, self.x0)) +
             mul(dae.x[self.ird], self.xmu, div(1, self.x0))), self.v,
         self.v)
コード例 #7
0
ファイル: windturbine.py プロジェクト: lieyanhonghu/Andes
    def gcall(self, dae):
        toSb = div(self.Sn, self.system.Settings.mva)
        dae.g[self.isd] = -dae.y[self.vsd] + mul(
            dae.x[self.irq], self.xmu) + mul(dae.y[self.isq], self.x0) - mul(
                dae.y[self.isd], self.rs)
        dae.g[self.isq] = -dae.y[self.vsq] - mul(
            dae.x[self.ird], self.xmu) - mul(dae.y[self.isd], self.x0) - mul(
                dae.y[self.isq], self.rs)
        dae.g[self.vrd] = -dae.y[self.vrd] + mul(
            1 - dae.x[self.omega_m],
            mul(dae.x[self.irq], self.x1) +
            mul(dae.y[self.isq], self.xmu)) - mul(dae.x[self.ird], self.rr)
        dae.g[self.vrq] = -dae.y[self.vrq] - mul(
            dae.x[self.irq], self.rr) - mul(
                1 - dae.x[self.omega_m],
                mul(dae.x[self.ird], self.x1) + mul(dae.y[self.isd], self.xmu))
        dae.g[self.vsd] = -dae.y[self.vsd] - mul(dae.y[self.v],
                                                 sin(dae.y[self.a]))
        dae.g[self.vsq] = -dae.y[self.vsq] + mul(dae.y[self.v],
                                                 cos(dae.y[self.a]))
        dae.g[self.vref] = self.vref0 - dae.y[self.vref]
        # dae.g[self.pwa] = mul(2*dae.x[self.omega_m] - 1, toSb) - dae.y[self.pwa]
        dae.g[self.pwa] = mmax(mmin(2 * dae.x[self.omega_m] - 1, 1),
                               0) - dae.y[self.pwa]

        dae.hard_limit(self.pwa, 0, 1)
        dae.g[self.pw] = -dae.y[self.pw] + mul(
            0.5, dae.y[self.cp], self.ngen, pi, self.rho, (self.R)**2,
            (self.Vwn)**3, div(1, self.mva_mega), (dae.x[self.vw])**3)
        dae.g[self.cp] = -dae.y[self.cp] + mul(
            -1.1 + mul(25.52, div(1, dae.y[self.ilamb])) +
            mul(-0.08800000000000001, dae.x[self.theta_p]),
            exp(mul(-12.5, div(1, dae.y[self.ilamb]))))
        dae.g[self.lamb] = -dae.y[self.lamb] + mul(
            4, self.R, self.fn, self.ngb, dae.x[self.omega_m], pi,
            div(1, self.Vwn), div(1, self.npole), div(1, dae.x[self.vw]))
        dae.g[self.ilamb] = div(
            1,
            div(1, dae.y[self.lamb] + mul(0.08, dae.x[self.theta_p])) +
            mul(-0.035, div(1, 1 +
                            (dae.x[self.theta_p])**3))) - dae.y[self.ilamb]
        dae.g += spmatrix(
            mul(
                self.u0, -mul(dae.x[self.ird], dae.y[self.vrd]) -
                mul(dae.x[self.irq], dae.y[self.vrq]) -
                mul(dae.y[self.isd], dae.y[self.vsd]) -
                mul(dae.y[self.isq], dae.y[self.vsq])), self.a, [0] * self.n,
            (dae.m, 1), 'd')
        dae.g += spmatrix(
            mul(
                self.u0,
                mul((dae.y[self.v])**2, div(1, self.x0)) +
                mul(dae.x[self.ird], dae.y[self.v], self.xmu, div(
                    1, self.x0))), self.v, [0] * self.n, (dae.m, 1), 'd')
コード例 #8
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
 def gcall(self, dae):
     self.speed_gcall(dae)
     self.voltage_gcall(dae)
     self.current_gcall(dae)
     dae.g[self.p] = -dae.y[self.p] + mul(dae.x[self.Id], dae.y[self.vd]) + mul(dae.x[self.Iq], dae.y[self.vq])
     dae.g[self.q] = -dae.y[self.q] + mul(dae.x[self.Iq], dae.y[self.vd]) - mul(dae.x[self.Id], dae.y[self.vq])
     dae.g[self.vd] = -dae.y[self.vd] + mul(self.u, dae.y[self.v], cos(dae.y[self.a] - dae.x[self.adq]))
     dae.g[self.vq] = -dae.y[self.vq] - mul(self.u, dae.y[self.v], sin(dae.y[self.a] - dae.x[self.adq]))
     dae.g += spmatrix(- mul(dae.y[self.p], self.u), self.a, [0]*self.n, (dae.m, 1), 'd')
     dae.g += spmatrix(- mul(dae.y[self.q], self.u), self.v, [0]*self.n, (dae.m, 1), 'd')
     dae.g += spmatrix(mul(self.u, div(1, dae.y[self.v1] - dae.y[self.v2]), mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v1, [0]*self.n, (dae.m, 1), 'd')
     dae.g += spmatrix(- mul(self.u, div(1, dae.y[self.v1] - dae.y[self.v2]), mul(dae.x[self.Id], dae.x[self.ud]) + mul(dae.x[self.Iq], dae.x[self.uq])), self.v2, [0]*self.n, (dae.m, 1), 'd')
コード例 #9
0
def cvx():
    # Figures 6.8-10, pages 313-314
    # Quadratic smoothing.

    from math import pi
    from cvxopt import blas, lapack, matrix, sin, mul, normal

    n = 4000
    t = matrix(list(range(n)), tc='d')
    ex = 0.5 * mul(sin(2 * pi / n * t), sin(0.01 * t))
    corr = ex + 0.05 * normal(n, 1)

    # A = D'*D is an n by n tridiagonal matrix with -1.0 on the
    # upper/lower diagonal and 1, 2, 2, ..., 2, 2, 1 on the diagonal.
    Ad = matrix([1.0] + (n - 2) * [2.0] + [1.0])
    As = matrix(-1.0, (n - 1, 1))

    nopts = 50
    deltas = -10.0 + 20.0 / (nopts - 1) * matrix(list(range(nopts)))
    cost1, cost2 = [], []
    for delta in deltas:
        xr = +corr
        lapack.ptsv(1.0 + 10 ** delta * Ad, 10 ** delta * As, xr)
        cost1 += [blas.nrm2(xr - corr)]
        cost2 += [blas.nrm2(xr[1:] - xr[:-1])]

    # Find solutions with ||xhat - xcorr || roughly equal to 8.0, 3.1, 1.0.
    time.sleep(1)
    mv1, k1 = min(zip([abs(c - 8.0) for c in cost1], range(nopts)))
    xr1 = +corr
    lapack.ptsv(1.0 + 10 ** deltas[k1] * Ad, 10 ** deltas[k1] * As, xr1)
    mv2, k2 = min(zip([abs(c - 3.1) for c in cost1], range(nopts)))
    xr2 = +corr
    lapack.ptsv(1.0 + 10 ** deltas[k2] * Ad, 10 ** deltas[k2] * As, xr2)
    mv3, k3 = min(zip([abs(c - 1.0) for c in cost1], range(nopts)))
    xr3 = +corr
    lapack.ptsv(1.0 + 10 ** deltas[k3] * Ad, 10 ** deltas[k3] * As, xr3)
コード例 #10
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def init1(self, dae):
        self.servcall(dae)

        self.pll_init1(dae)

        dae.y[self.ref1] = self.ref10
        dae.y[self.ref2] = self.ref20
        dae.y[self.vd] = mul(dae.y[self.v], cos(dae.y[self.a] - dae.y[self.adq]))
        dae.y[self.vq] = - mul(dae.y[self.v], sin(dae.y[self.a] - dae.y[self.adq]))

        self.current_init1(dae)
        self.outer_init1(dae)

        dae.y[self.p] = mul(dae.x[self.Id], dae.y[self.vd]) + mul(dae.x[self.Iq], dae.y[self.vq])
        dae.y[self.q] = mul(dae.x[self.Iq], dae.y[self.vd]) - mul(dae.x[self.Id], dae.y[self.vq])

        for idx in self.vsc:
            self.system.VSC.disable(idx)
コード例 #11
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def gcall(self, dae):
        self.pll_gcall(dae)
        self.outer_gcall(dae)
        self.current_gcall(dae)

        dae.g[self.ref1] = self.ref10 - dae.y[self.ref1] \
                           + mul(self.PQ + self.PV, mul(self.v12 - self.v120, self.Kdc)) \
                           - mul(self.PQ + self.PV, mul(dae.x[self.w] - 1), self.Kf) \
                           + mul(self.vV + self.vQ, self.Kp, dae.y[self.p] - self.pref0)\
                           - mul(self.vV + self.vQ, mul(dae.x[self.w] - 1), self.Kf)

        dae.g[self.ref2] = self.ref20 - dae.y[self.ref2]
        dae.g[self.vd] = -dae.y[self.vd] + mul(dae.y[self.v], cos(dae.y[self.a] - dae.y[self.adq]))
        dae.g[self.vq] = -dae.y[self.vq] - mul(dae.y[self.v], sin(dae.y[self.a] - dae.y[self.adq]))
        dae.g[self.p] = -dae.y[self.p] + mul(dae.x[self.Id], dae.y[self.vd]) + mul(dae.x[self.Iq], dae.y[self.vq])
        dae.g[self.q] = -dae.y[self.q] + mul(dae.x[self.Iq], dae.y[self.vd]) - mul(dae.x[self.Id], dae.y[self.vq])
        dae.g += spmatrix(- dae.y[self.p], self.a, [0]*self.n, (dae.m, 1), 'd')
        dae.g += spmatrix(- dae.y[self.q], self.v, [0]*self.n, (dae.m, 1), 'd')
コード例 #12
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def fxcall(self, dae):
        self.speed_fxcall(dae)
        self.voltage_fxcall(dae)
        self.current_fxcall(dae)

        dae.add_jac(Gx, dae.y[self.vq], self.p, self.Iq)
        dae.add_jac(Gx, dae.y[self.vd], self.p, self.Id)
        dae.add_jac(Gx, dae.y[self.vd], self.q, self.Iq)
        dae.add_jac(Gx, - dae.y[self.vq], self.q, self.Id)
        dae.add_jac(Gx, mul(self.u, dae.y[self.v], sin(dae.y[self.a] - dae.x[self.adq])), self.vd, self.adq)
        dae.add_jac(Gx, mul(self.u, dae.y[self.v], cos(dae.y[self.a] - dae.x[self.adq])), self.vq, self.adq)
        dae.add_jac(Gx, mul(self.u, dae.x[self.uq], div(1, dae.y[self.v1] - dae.y[self.v2])), self.v1, self.Iq)
        dae.add_jac(Gx, mul(self.u, dae.x[self.ud], div(1, dae.y[self.v1] - dae.y[self.v2])), self.v1, self.Id)
        dae.add_jac(Gx, mul(dae.x[self.Id], self.u, div(1, dae.y[self.v1] - dae.y[self.v2])), self.v1, self.ud)
        dae.add_jac(Gx, mul(dae.x[self.Iq], self.u, div(1, dae.y[self.v1] - dae.y[self.v2])), self.v1, self.uq)
        dae.add_jac(Gx, - mul(self.u, dae.x[self.uq], div(1, dae.y[self.v1] - dae.y[self.v2])), self.v2, self.Iq)
        dae.add_jac(Gx, - mul(self.u, dae.x[self.ud], div(1, dae.y[self.v1] - dae.y[self.v2])), self.v2, self.Id)
        dae.add_jac(Gx, - mul(dae.x[self.Id], self.u, div(1, dae.y[self.v1] - dae.y[self.v2])), self.v2, self.ud)
        dae.add_jac(Gx, - mul(dae.x[self.Iq], self.u, div(1, dae.y[self.v1] - dae.y[self.v2])), self.v2, self.uq)
コード例 #13
0
from math import pi
from cvxopt import blas, lapack, solvers
from cvxopt import matrix, spmatrix, sin, mul, div, normal
#solvers.options['show_progress'] = 0
try:
    import pylab
except ImportError:
    pylab_installed = False
else:
    pylab_installed = True

n = 2000
t = matrix(list(range(n)), tc='d')
ex = matrix( n//4*[1.0] + n//4*[-1.0] + n//4*[1.0] + n//4*[-1.0] ) + \
    0.5 * sin( 2.0*pi/n * t )
corr = ex + 0.1 * normal(n, 1)

if pylab_installed:
    pylab.figure(1, facecolor='w', figsize=(8, 5))
    pylab.subplot(211)
    pylab.plot(t, ex)
    pylab.ylabel('x[i]')
    pylab.xlabel('i')
    pylab.axis([0, 2000, -2, 2])
    pylab.title('Original and corrupted signal (fig. 6.11)')
    pylab.subplot(212)
    pylab.plot(t, corr)
    pylab.ylabel('xcor[i]')
    pylab.xlabel('i')
    pylab.axis([0, 2000, -2, 2])
コード例 #14
0
ファイル: basispursuit.py プロジェクト: AlbertHolmes/cvxopt
# Build dictionary matrix
ts = (1.0/N) * matrix(range(N), tc='d')
B = ts[:, K*[0]] - tau * matrix(range(K), (1,K), 'd')[N*[0],:]
B = exp(-(B/sigma)**2)
A = matrix(0.0, (N, K*(2*L+1)))

# First K columns are DC pulses for k = 0,...,K-1
A[:,:K] = B
for l in range(L):

    # Cosine pulses for omega = (l+1)*omega0 and k = 0,...,K-1.
    A[:, K+l*(2*K) : K+l*(2*K)+K] = mul(B, cos((l+1)*omega0*ts)[:, K*[0]])

    # Sine pulses for omega = (l+1)*omega0 and k = 0,...,K-1.
    A[:, K+l*(2*K)+K : K+(l+1)*(2*K)] = \
        mul(B, sin((l+1)*omega0*ts)[:,K*[0]])

if pylab_installed:

    pylab.figure(1, facecolor='w')
    pylab.subplot(311)
    # DC pulse for k = 250 (tau = 0.5)
    pylab.plot(ts, A[:,250])
    pylab.ylabel('f(0.5, 0, c)')
    pylab.axis([0, 1, -1, 1])
    pylab.title('Three basis elements (fig. 6.21)')
    # Cosine pulse for k = 250 (tau = 0.5) and l = 15  (omega = 75)
    pylab.subplot(312)
    pylab.ylabel('f(0.5, 75, c)')
    pylab.plot(ts, A[:, K + 14*(2*K) + 250])
    pylab.axis([0, 1, -1, 1])
コード例 #15
0
B = ts[:, K * [0]] - tau * matrix(range(K), (1, K), 'd')[N * [0], :]
B = exp(-(B / sigma)**2)
A = matrix(0.0, (N, K * (2 * L + 1)))

# First K columns are DC pulses for k = 0,...,K-1
A[:, :K] = B
for l in range(L):

    # Cosine pulses for omega = (l+1)*omega0 and k = 0,...,K-1.
    A[:, K + l * (2 * K):K + l * (2 * K) + K] = mul(
        B,
        cos((l + 1) * omega0 * ts)[:, K * [0]])

    # Sine pulses for omega = (l+1)*omega0 and k = 0,...,K-1.
    A[:, K+l*(2*K)+K : K+(l+1)*(2*K)] = \
        mul(B, sin((l+1)*omega0*ts)[:,K*[0]])

if pylab_installed:

    pylab.figure(1, facecolor='w')
    pylab.subplot(311)
    # DC pulse for k = 250 (tau = 0.5)
    pylab.plot(ts, A[:, 250])
    pylab.ylabel('f(0.5, 0, c)')
    pylab.axis([0, 1, -1, 1])
    pylab.title('Three basis elements (fig. 6.21)')
    # Cosine pulse for k = 250 (tau = 0.5) and l = 15  (omega = 75)
    pylab.subplot(312)
    pylab.ylabel('f(0.5, 75, c)')
    pylab.plot(ts, A[:, K + 14 * (2 * K) + 250])
    pylab.axis([0, 1, -1, 1])
コード例 #16
0
ファイル: tv.py プロジェクト: sanurielf/cvxopt
# Figures 6.11-14, pages 315-317.
# Total variation reconstruction.

from math import pi
from cvxopt import blas, lapack, solvers 
from cvxopt import matrix, spmatrix, sin, mul, div, normal
#solvers.options['show_progress'] = 0
try: import pylab
except ImportError: pylab_installed = False
else: pylab_installed = True

n = 2000
t = matrix( list(range(n)), tc='d' )
ex = matrix( n//4*[1.0] + n//4*[-1.0] + n//4*[1.0] + n//4*[-1.0] ) + \
    0.5 * sin( 2.0*pi/n * t )
corr = ex + 0.1 * normal(n,1)

if pylab_installed:
    pylab.figure(1, facecolor='w', figsize=(8,5))
    pylab.subplot(211)
    pylab.plot(t, ex)
    pylab.ylabel('x[i]')
    pylab.xlabel('i')
    pylab.axis([0, 2000, -2, 2])
    pylab.title('Original and corrupted signal (fig. 6.11)')
    pylab.subplot(212)
    pylab.plot(t, corr)
    pylab.ylabel('xcor[i]')
    pylab.xlabel('i')
    pylab.axis([0, 2000, -2, 2])
コード例 #17
0
ファイル: windturbine.py プロジェクト: mzy2240/andes
    def init1(self, dae):
        """New initialization function"""
        self.servcall(dae)
        retval = True

        mva = self.system.mva
        self.p0 = mul(self.p0, self.gammap)
        self.q0 = mul(self.q0, self.gammaq)

        dae.y[self.vsd] = mul(dae.y[self.v], -sin(dae.y[self.a]))
        dae.y[self.vsq] = mul(dae.y[self.v], cos(dae.y[self.a]))

        rs = matrix(self.rs)
        rr = matrix(self.rr)
        xmu = matrix(self.xmu)
        x1 = matrix(self.xs) + xmu
        x2 = matrix(self.xr) + xmu
        Pg = matrix(self.p0)
        Qg = matrix(self.q0)
        Vc = dae.y[self.v]
        vsq = dae.y[self.vsq]
        vsd = dae.y[self.vsd]

        toSn = div(mva, self.Sn)  # to machine base
        toSb = self.Sn / mva  # to system base

        # rotor speed
        omega = 1 * (ageb(mva * Pg, self.Sn)) + \
            mul(0.5 + 0.5 * mul(Pg, toSn),
                aandb(agtb(Pg, 0), altb(mva * Pg, self.Sn))) + \
            0.5 * (aleb(mva * Pg, 0))

        slip = 1 - omega
        theta = mul(self.Kp, mround(1000 * (omega - 1)) / 1000)
        theta = mmax(theta, 0)

        # prepare for the iterations

        irq = mul(-x1, toSb, (2 * omega - 1), div(1, Vc), div(1, xmu),
                  div(1, omega))
        isd = zeros(*irq.size)
        isq = zeros(*irq.size)

        # obtain ird isd isq
        for i in range(self.n):
            A = sparse([[-rs[i], vsq[i]], [x1[i], -vsd[i]]])
            B = matrix([vsd[i] - xmu[i] * irq[i], Qg[i]])
            linsolve(A, B)
            isd[i] = B[0]
            isq[i] = B[1]
        ird = -div(vsq + mul(rs, isq) + mul(x1, isd), xmu)
        vrd = -mul(rr, ird) + mul(
            slip,
            mul(x2, irq) + mul(xmu, isq))  # todo: check x1 or x2
        vrq = -mul(rr, irq) - mul(slip, mul(x2, ird) + mul(xmu, isd))

        # main iterations
        for i in range(self.n):
            mis = ones(6, 1)
            rows = [0, 0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5]
            cols = [0, 1, 3, 0, 1, 2, 2, 4, 3, 5, 0, 1, 2]

            x = matrix([isd[i], isq[i], ird[i], irq[i], vrd[i], vrq[i]])
            # vals = [-rs, x1, xmu, -x1, -rs, -xmu, -rr,
            #         -1, -rr, -1, vsd, vsq, -xmu * Vc / x1]

            vals = [
                -rs[i], x1[i], xmu[i], -x1[i], -rs[i], -xmu[i], -rr[i], -1,
                -rr[i], -1, vsd[i], vsq[i], -xmu[i] * Vc[i] / x1[i]
            ]
            jac0 = spmatrix(vals, rows, cols, (6, 6), 'd')
            niter = 0

            while max(abs(mis)) > self.system.tds.config.tol:
                if niter > 20:
                    logger.error('Initialization of DFIG <{}> failed.'.format(
                        self.name[i]))
                    retval = False
                    break

                mis[0] = -rs[i] * x[0] + x1[i] * x[1] + xmu[i] * x[3] - vsd[i]
                mis[1] = -rs[i] * x[1] - x1[i] * x[0] - xmu[i] * x[2] - vsq[i]
                mis[2] = -rr[i] * x[2] + slip[i] * (x2[i] * x[3] +
                                                    xmu[i] * x[1]) - x[4]
                mis[3] = -rr[i] * x[3] - slip[i] * (x2[i] * x[2] +
                                                    xmu[i] * x[0]) - x[5]
                mis[4] = vsd[i] * x[0] + vsq[i] * x[1] + x[4] * x[2] + \
                    x[5] * x[3] - Pg[i]
                mis[5] = -xmu[i] * Vc[i] * x[2] / x1[i] - \
                    Vc[i] * Vc[i] / x1[i] - Qg[i]

                rows = [2, 2, 3, 3, 4, 4, 4, 4]
                cols = [1, 3, 0, 2, 2, 3, 4, 5]
                vals = [
                    slip[i] * xmu[i], slip[i] * x2[i], -slip[i] * xmu[i],
                    -slip[i] * x2[i], x[4], x[5], x[2], x[3]
                ]

                jac = jac0 + spmatrix(vals, rows, cols, (6, 6), 'd')

                linsolve(jac, mis)

                x -= mis
                niter += 1

            isd[i] = x[0]
            isq[i] = x[1]
            ird[i] = x[2]
            irq[i] = x[3]
            vrd[i] = x[4]
            vrq[i] = x[5]

        dae.x[self.ird] = mul(self.u0, ird)
        dae.x[self.irq] = mul(self.u0, irq)
        dae.y[self.isd] = isd
        dae.y[self.isq] = isq
        dae.y[self.vrd] = vrd
        dae.y[self.vrq] = vrq

        dae.x[self.omega_m] = mul(self.u0, omega)
        dae.x[self.theta_p] = mul(self.u0, theta)
        dae.y[self.pwa] = mmax(mmin(2 * dae.x[self.omega_m] - 1, 1), 0)

        self.vref0 = mul(aneb(self.KV, 0),
                         Vc - div(ird + div(Vc, xmu), self.KV))
        dae.y[self.vref] = self.vref0
        k = mul(div(x1, Vc, xmu, omega), toSb)

        self.irq_off = -mul(k, mmax(mmin(2 * omega - 1, 1), 0)) - irq

        # electrical torque in pu
        te = mul(
            xmu,
            mul(dae.x[self.irq], dae.y[self.isd]) -
            mul(dae.x[self.ird], dae.y[self.isq]))

        for i in range(self.n):
            if te[i] < 0:
                logger.error(
                    'Pe < 0 on bus <{}>. Wind speed initialize failed.'.format(
                        self.bus[i]))
                retval = False

        # wind power in pu
        pw = mul(te, omega)
        dae.y[self.pw] = pw

        # wind speed initialization loop

        R = 4 * pi * self.system.freq * mul(self.R, self.ngb, div(
            1, self.npole))
        AA = pi * self.R**2
        vw = 0.9 * self.Vwn

        for i in range(self.n):
            mis = 1
            niter = 0
            while abs(mis) > self.system.tds.config.tol:
                if niter > 50:
                    logger.error(
                        'Wind <{}> init failed. '
                        'Try increasing the nominal wind speed.'.format(
                            self.wind[i]))
                    retval = False
                    break

                pw_iter, jac = self.windpower(self.ngen[i], self.rho[i], vw[i],
                                              AA[i], R[i], omega[i], theta[i])

                mis = pw_iter - pw[i]
                inc = -mis / jac[1]
                vw[i] += inc
                niter += 1

        # set wind speed
        dae.x[self.vw] = div(vw, self.Vwn)

        lamb = div(omega, vw, div(1, R))
        ilamb = div(1,
                    (div(1, lamb + 0.08 * theta) - div(0.035, theta**3 + 1)))
        cp = 0.22 * mul(
            div(116, ilamb) - 0.4 * theta - 5, exp(div(-12.5, ilamb)))

        dae.y[self.lamb] = lamb
        dae.y[self.ilamb] = ilamb
        dae.y[self.cp] = cp

        self.system.rmgen(self.gen)

        if not retval:
            logger.error('DFIG initialization failed')

        return retval
コード例 #18
0
# Figures 6.8-10, pages 313-314
# Quadratic smoothing.

from math import pi
from cvxopt import blas, lapack, matrix, sin, mul, normal
try:
    import pylab
except ImportError:
    pylab_installed = False
else:
    pylab_installed = True

n = 4000
t = matrix(list(range(n)), tc='d')
ex = 0.5 * mul(sin(2 * pi / n * t), sin(0.01 * t))
corr = ex + 0.05 * normal(n, 1)

if pylab_installed:
    pylab.figure(1, facecolor='w', figsize=(8, 5))
    pylab.subplot(211)
    pylab.plot(t, ex)
    pylab.ylabel('x[i]')
    pylab.xlabel('i')
    pylab.title('Original and corrupted signal (fig. 6.8)')
    pylab.subplot(212)
    pylab.plot(t, corr)
    pylab.ylabel('xcor[i]')
    pylab.xlabel('i')

# A = D'*D is an n by n tridiagonal matrix with -1.0 on the
# upper/lower diagonal and 1, 2, 2, ..., 2, 2, 1 on the diagonal.
コード例 #19
0
ファイル: robls.py プロジェクト: AlbertHolmes/cvxopt
# Tikhonov solution:  minimize || A*x - b ||_2^2 + 0.1*||x||^2_2
xtik = A.T*b
S = A.T*A
S[::n+1] += 0.1
lapack.posv(S, xtik)

# Worst case solution
xwc = wcls(A, Ap, b)

notrials = 100000
r = sqrt(uniform(1,notrials))
theta = 2.0 * pi * uniform(1,notrials)
u = matrix(0.0, (2,notrials))
u[0,:] = mul(r, cos(theta))
u[1,:] = mul(r, sin(theta))

# LS solution 
q = A*xls - b
P = matrix(0.0, (m,2))
P[:,0], P[:,1] = Ap[0]*xls, Ap[1]*xls
r = P*u + q[:,notrials*[0]]
resls = sqrt( matrix(1.0, (1,m)) * mul(r,r) )

q = A*xtik - b
P[:,0], P[:,1] = Ap[0]*xtik, Ap[1]*xtik
r = P*u + q[:,notrials*[0]]
restik = sqrt( matrix(1.0, (1,m)) * mul(r,r) )

q = A*xwc - b
P[:,0], P[:,1] = Ap[0]*xwc, Ap[1]*xwc
コード例 #20
0
ファイル: vsc.py プロジェクト: lieyanhonghu/Andes
    def gycall(self, dae):
        if sum(self.u) == 0:
            return
        Zsh = self.rsh + 1j * self.xsh
        iZsh = div(self.u, abs(Zsh))
        Vh = polar(dae.y[self.v], dae.y[self.a] * 1j)
        Vsh = polar(dae.y[self.vsh], dae.y[self.ash] * 1j)
        Ish = div(Vsh - Vh + 1e-6, Zsh)
        iIsh = div(self.u, Ish)

        gsh = div(self.u, Zsh).real()
        bsh = div(self.u, Zsh).imag()
        V = dae.y[self.v]
        theta = dae.y[self.a]
        Vsh = dae.y[self.vsh]
        thetash = dae.y[self.ash]
        Vdc = dae.y[self.v1] - dae.y[self.v2]
        iVdc2 = div(self.u, Vdc ** 2)

        dae.add_jac(Gy, div(self.u, Vdc), self.v1, self.pdc)
        dae.add_jac(Gy, -mul(self.u, dae.y[self.pdc], iVdc2), self.v1, self.v1)
        dae.add_jac(Gy, mul(self.u, dae.y[self.pdc], iVdc2), self.v1, self.v2)

        dae.add_jac(Gy, -div(self.u, Vdc), self.v2, self.pdc)
        dae.add_jac(Gy, mul(self.u, dae.y[self.pdc], iVdc2), self.v2, self.v1)
        dae.add_jac(Gy, -mul(self.u, dae.y[self.pdc], iVdc2), self.v2, self.v2)

        dae.add_jac(Gy, -2*mul(gsh, V) + mul(gsh, Vsh, cos(theta - thetash)) + mul(bsh, Vsh, sin(theta - thetash)), self.ash, self.v)
        dae.add_jac(Gy, mul(gsh, V, cos(theta - thetash)) + mul(bsh, V, sin(theta - thetash)), self.ash, self.vsh)
        dae.add_jac(Gy, -mul(gsh, V, Vsh, sin(theta - thetash)) + mul(bsh, V, Vsh, cos(theta - thetash)), self.ash, self.a)
        dae.add_jac(Gy, mul(gsh, V, Vsh, sin(theta - thetash)) - mul(bsh, V, Vsh, cos(theta - thetash)), self.ash, self.ash)

        dae.add_jac(Gy, 2*mul(bsh, V) + mul(gsh, Vsh, sin(theta - thetash)) - mul(bsh, Vsh, cos(theta - thetash)), self.vsh, self.v)
        dae.add_jac(Gy, mul(gsh, V, sin(theta - thetash)) - mul(bsh, V, cos(theta - thetash)), self.vsh, self.vsh)
        dae.add_jac(Gy, mul(gsh, V, Vsh, cos(theta - thetash)) + mul(bsh, V, Vsh, sin(theta - thetash)), self.vsh, self.a)
        dae.add_jac(Gy, -mul(gsh, V, Vsh, cos(theta - thetash)) - mul(bsh, V, Vsh, sin(theta - thetash)), self.vsh, self.ash)

        dae.add_jac(Gy, 0.5 * mul(self.u, 2*V - 2*mul(Vsh, cos(theta - thetash)), abs(iIsh), abs(iZsh) ** 2), self.Ish, self.v)
        dae.add_jac(Gy, 0.5 * mul(self.u, 2*Vsh - 2*mul(V, cos(theta - thetash)), abs(iIsh), abs(iZsh) ** 2), self.Ish, self.vsh)
        dae.add_jac(Gy, 0.5 * mul(self.u, 2*V, Vsh, sin(theta-thetash), abs(iIsh), abs(iZsh) ** 2), self.Ish, self.a)
        dae.add_jac(Gy, 0.5 * mul(self.u, 2*V, Vsh, - sin(theta - thetash), abs(iIsh), abs(iZsh) ** 2), self.Ish, self.ash)

        dae.add_jac(Gy, -2 * mul(self.u, self.k2, dae.y[self.Ish]), self.pdc, self.Ish)

        dae.add_jac(Gy, mul(2 * gsh, Vsh) - mul(gsh, V, cos(theta - thetash)) + mul(bsh, V, sin(theta - thetash)), self.pdc, self.vsh)
        dae.add_jac(Gy, -mul(gsh, Vsh, cos(theta - thetash)) + mul(bsh, Vsh, sin(theta - thetash)), self.pdc, self.v)
        dae.add_jac(Gy, mul(gsh, V, Vsh, sin(theta - thetash)) + mul(bsh, V, Vsh, cos(theta - thetash)), self.pdc, self.a)
        dae.add_jac(Gy, -mul(gsh, V, Vsh, sin(theta - thetash)) - mul(bsh, V, Vsh, cos(theta - thetash)), self.pdc, self.ash)

        for gidx, yidx in zip(self.glim, self.ylim):
            dae.set_jac(Gy, 0.0, [gidx] * dae.m, range(dae.m))
            dae.set_jac(Gy, 1.0, [gidx], [yidx])
            dae.set_jac(Gy, -1e-6, [gidx], [gidx])
コード例 #21
0
ファイル: smoothrec.py プロジェクト: AlbertHolmes/cvxopt
# Figures 6.8-10, pages 313-314
# Quadratic smoothing.

from math import pi
from cvxopt import blas, lapack, matrix, sin, mul, normal
try: import pylab
except ImportError: pylab_installed = False
else: pylab_installed = True

n = 4000
t = matrix(list(range(n)), tc='d')
ex = 0.5 * mul( sin(2*pi/n * t), sin(0.01 * t))
corr = ex + 0.05 * normal(n,1)

if pylab_installed:
    pylab.figure(1, facecolor='w', figsize=(8,5))
    pylab.subplot(211)
    pylab.plot(t, ex)
    pylab.ylabel('x[i]')
    pylab.xlabel('i')
    pylab.title('Original and corrupted signal (fig. 6.8)')
    pylab.subplot(212)
    pylab.plot(t, corr)
    pylab.ylabel('xcor[i]')
    pylab.xlabel('i')


# A = D'*D is an n by n tridiagonal matrix with -1.0 on the 
# upper/lower diagonal and 1, 2, 2, ..., 2, 2, 1 on the diagonal.
Ad = matrix([1.0] + (n-2)*[2.0] + [1.0])
As = matrix(-1.0, (n-1,1))
コード例 #22
0
ファイル: ellipsoids.py プロジェクト: sfu-db/quicksel
if pylab_installed:
    pylab.figure(1, facecolor='w')
    pylab.plot(X[:, 0], X[:, 1], 'ko', X[:, 0], X[:, 1], '-k')

    # Ellipsoid in the form { x | || L' * (x-c) ||_2 <= 1 }
    L = +A
    lapack.potrf(L)
    c = +b
    lapack.potrs(L, c)

    # 1000 points on the unit circle
    nopts = 1000
    angles = matrix([a * 2.0 * pi / nopts for a in range(nopts)], (1, nopts))
    circle = matrix(0.0, (2, nopts))
    circle[0, :], circle[1, :] = cos(angles), sin(angles)

    # ellipse = L^-T * circle + c
    blas.trsm(L, circle, transA='T')
    ellipse = circle + c[:, nopts * [0]]
    ellipse2 = 0.5 * circle + c[:, nopts * [0]]

    pylab.plot(ellipse[0, :].T, ellipse[1, :].T, 'k-')
    pylab.fill(ellipse2[0, :].T, ellipse2[1, :].T, facecolor='#F0F0F0')
    pylab.title('Loewner-John ellipsoid (fig 8.3)')
    pylab.axis('equal')
    pylab.axis('off')

# Maximum volume enclosed ellipsoid
#
# minimize    -log det B
コード例 #23
0
ファイル: robls.py プロジェクト: sfu-db/quicksel
# Tikhonov solution:  minimize || A*x - b ||_2^2 + 0.1*||x||^2_2
xtik = A.T * b
S = A.T * A
S[::n + 1] += 0.1
lapack.posv(S, xtik)

# Worst case solution
xwc = wcls(A, Ap, b)

notrials = 100000
r = sqrt(uniform(1, notrials))
theta = 2.0 * pi * uniform(1, notrials)
u = matrix(0.0, (2, notrials))
u[0, :] = mul(r, cos(theta))
u[1, :] = mul(r, sin(theta))

# LS solution
q = A * xls - b
P = matrix(0.0, (m, 2))
P[:, 0], P[:, 1] = Ap[0] * xls, Ap[1] * xls
r = P * u + q[:, notrials * [0]]
resls = sqrt(matrix(1.0, (1, m)) * mul(r, r))

q = A * xtik - b
P[:, 0], P[:, 1] = Ap[0] * xtik, Ap[1] * xtik
r = P * u + q[:, notrials * [0]]
restik = sqrt(matrix(1.0, (1, m)) * mul(r, r))

q = A * xwc - b
P[:, 0], P[:, 1] = Ap[0] * xwc, Ap[1] * xwc
コード例 #24
0
    def gycall(self, dae):
        Zsh = self.rsh + 1j * self.xsh
        iZsh = div(1, abs(Zsh))
        V = polar(dae.y[self.v], dae.y[self.a] * 1j)
        Vsh = polar(dae.y[self.vsh], dae.y[self.ash] * 1j)
        Ish = div(V - Vsh, Zsh)
        iIsh = div(1, Ish)

        gsh = div(1, Zsh).real()
        bsh = div(1, Zsh).imag()
        V = dae.y[self.v]
        theta = dae.y[self.a]
        Vsh = dae.y[self.vsh]
        thetash = dae.y[self.ash]
        Vdc = dae.y[self.v1] - dae.y[self.v2]

        dae.add_jac(Gy, -div(1, Vdc), self.v1, self.pdc)
        dae.add_jac(Gy, div(dae.y[self.pdc], mul(Vdc, Vdc)), self.v1, self.v1)
        dae.add_jac(Gy, -div(dae.y[self.pdc], mul(Vdc, Vdc)), self.v1, self.v2)

        dae.add_jac(Gy, div(1, Vdc), self.v2, self.pdc)
        dae.add_jac(Gy, -div(dae.y[self.pdc], mul(Vdc, Vdc)), self.v2, self.v1)
        dae.add_jac(Gy, div(dae.y[self.pdc], mul(Vdc, Vdc)), self.v2, self.v2)

        dae.add_jac(
            Gy, 2 * mul(gsh, V) - mul(gsh, Vsh, cos(theta - thetash)) -
            mul(bsh, Vsh, sin(theta - thetash)), self.ash, self.v)
        dae.add_jac(
            Gy, -mul(gsh, V, cos(theta - thetash)) -
            mul(bsh, V, sin(theta - thetash)), self.ash, self.vsh)
        dae.add_jac(
            Gy,
            mul(gsh, V, Vsh, sin(theta - thetash)) -
            mul(bsh, V, Vsh, cos(theta - thetash)), self.ash, self.a)
        dae.add_jac(
            Gy, -mul(gsh, V, Vsh, sin(theta - thetash)) +
            mul(bsh, V, Vsh, cos(theta - thetash)) + 1e-6, self.ash, self.ash)

        dae.add_jac(
            Gy, -2 * mul(bsh, V) - mul(gsh, Vsh, sin(theta - thetash)) +
            mul(bsh, Vsh, cos(theta - thetash)), self.vsh, self.v)
        dae.add_jac(
            Gy, -mul(gsh, V, sin(theta - thetash)) +
            mul(bsh, V, cos(theta - thetash)), self.vsh, self.vsh)
        dae.add_jac(
            Gy, -mul(gsh, V, Vsh, cos(theta - thetash)) -
            mul(bsh, V, Vsh, sin(theta - thetash)), self.vsh, self.a)
        dae.add_jac(
            Gy,
            mul(gsh, V, Vsh, cos(theta - thetash)) +
            mul(bsh, V, Vsh, sin(theta - thetash)), self.vsh, self.ash)

        dae.add_jac(
            Gy,
            0.5 * mul(2 * V - 2 * mul(Vsh, cos(theta - thetash)), abs(iIsh),
                      abs(iZsh), abs(iZsh)), self.Ish, self.v)
        dae.add_jac(
            Gy,
            0.5 * mul(2 * Vsh - 2 * mul(V, cos(theta - thetash)), abs(iIsh),
                      abs(iZsh), abs(iZsh)), self.Ish, self.vsh)
        dae.add_jac(
            Gy,
            0.5 * mul(2 * V, Vsh, sin(theta - thetash), abs(iIsh), abs(iZsh),
                      abs(iZsh)), self.Ish, self.a)
        dae.add_jac(
            Gy, 0.5 * mul(2 * V, Vsh, -sin(theta - thetash), abs(iIsh),
                          abs(iZsh), abs(iZsh)), self.Ish, self.ash)

        dae.add_jac(Gy, -2 * mul(self.k2, dae.y[self.Ish]), self.pdc, self.Ish)

        dae.add_jac(
            Gy, -mul(2 * gsh, Vsh) + mul(gsh, V, cos(theta - thetash)) -
            mul(bsh, V, sin(theta - thetash)), self.pdc, self.vsh)
        dae.add_jac(
            Gy,
            mul(gsh, Vsh, cos(theta - thetash)) -
            mul(bsh, Vsh, sin(theta - thetash)), self.pdc, self.v)
        dae.add_jac(
            Gy, -mul(gsh, V, Vsh, sin(theta - thetash)) -
            mul(bsh, V, Vsh, cos(theta - thetash)), self.pdc, self.a)
        dae.add_jac(
            Gy,
            mul(gsh, V, Vsh, sin(theta - thetash)) +
            mul(bsh, V, Vsh, cos(theta - thetash)), self.pdc, self.ash)
        dae.add_jac(Gy, -self.R, self.pdc, self.v1)

        for gidx, yidx in zip(self.glim, self.ylim):
            dae.set_jac(Gy, 0.0, [gidx] * dae.m, range(dae.m))
            dae.set_jac(Gy, 1.0, [gidx], [yidx])
            dae.set_jac(Gy, 1e-6, [gidx], [gidx])
コード例 #25
0
ファイル: ellipsoids.py プロジェクト: AlbertHolmes/cvxopt
if pylab_installed:
    pylab.figure(1, facecolor='w')
    pylab.plot(X[:,0], X[:,1], 'ko', X[:,0], X[:,1], '-k')
    
    # Ellipsoid in the form { x | || L' * (x-c) ||_2 <= 1 }
    L = +A
    lapack.potrf(L)
    c = +b
    lapack.potrs(L, c)    
    
    # 1000 points on the unit circle
    nopts = 1000
    angles = matrix( [ a*2.0*pi/nopts for a in range(nopts) ], (1,nopts) )
    circle = matrix(0.0, (2,nopts))
    circle[0,:], circle[1,:] = cos(angles), sin(angles)
    
    # ellipse = L^-T * circle + c
    blas.trsm(L, circle, transA='T')
    ellipse = circle + c[:, nopts*[0]]
    ellipse2 = 0.5 * circle + c[:, nopts*[0]]
    
    pylab.plot(ellipse[0,:].T, ellipse[1,:].T, 'k-')
    pylab.fill(ellipse2[0,:].T, ellipse2[1,:].T, facecolor = '#F0F0F0')
    pylab.title('Loewner-John ellipsoid (fig 8.3)')
    pylab.axis('equal')
    pylab.axis('off')


# Maximum volume enclosed ellipsoid
#
コード例 #26
0
ファイル: tv.py プロジェクト: AlbertHolmes/cvxopt
from math import pi
from cvxopt import blas, lapack, solvers
from cvxopt import matrix, spmatrix, sin, mul, div, normal

# solvers.options['show_progress'] = 0
try:
    import pylab
except ImportError:
    pylab_installed = False
else:
    pylab_installed = True

n = 2000
t = matrix(list(range(n)), tc="d")
ex = matrix(n // 4 * [1.0] + n // 4 * [-1.0] + n // 4 * [1.0] + n // 4 * [-1.0]) + 0.5 * sin(2.0 * pi / n * t)
corr = ex + 0.1 * normal(n, 1)

if pylab_installed:
    pylab.figure(1, facecolor="w", figsize=(8, 5))
    pylab.subplot(211)
    pylab.plot(t, ex)
    pylab.ylabel("x[i]")
    pylab.xlabel("i")
    pylab.axis([0, 2000, -2, 2])
    pylab.title("Original and corrupted signal (fig. 6.11)")
    pylab.subplot(212)
    pylab.plot(t, corr)
    pylab.ylabel("xcor[i]")
    pylab.xlabel("i")
    pylab.axis([0, 2000, -2, 2])