def dfdx(guess):
network.buses_t.v_ang.loc[now,sub_network.pvpqs] = guess[:len(sub_network.pvpqs)]
network.buses_t.v_mag_pu.loc[now,sub_network.pqs] = guess[len(sub_network.pvpqs):]
v_mag_pu = network.buses_t.v_mag_pu.loc[now,buses_o]
v_ang = network.buses_t.v_ang.loc[now,buses_o]
V = v_mag_pu*np.exp(1j*v_ang)
index = r_[:len(buses_o)]
#make sparse diagonal matrices
V_diag = csr_matrix((V,(index,index)))
V_norm_diag = csr_matrix((V/abs(V),(index,index)))
I_diag = csr_matrix((sub_network.Y*V,(index,index)))
dS_dVa = 1j*V_diag*np.conj(I_diag - sub_network.Y*V_diag)
dS_dVm = V_norm_diag*np.conj(I_diag) + V_diag * np.conj(sub_network.Y*V_norm_diag)
J00 = dS_dVa[1:,1:].real
J01 = dS_dVm[1:,1+len(sub_network.pvs):].real
J10 = dS_dVa[1+len(sub_network.pvs):,1:].imag
J11 = dS_dVm[1+len(sub_network.pvs):,1+len(sub_network.pvs):].imag
J = svstack([
shstack([J00, J01]),
shstack([J10, J11])
], format="csr")
return J
def dfdx(guess):
network.buses_t.v_ang.loc[now,sub_network.pvpqs] = guess[:len(sub_network.pvpqs)]
network.buses_t.v_mag_pu.loc[now,sub_network.pqs] = guess[len(sub_network.pvpqs):]
v_mag_pu = network.buses_t.v_mag_pu.loc[now,buses_o]
v_ang = network.buses_t.v_ang.loc[now,buses_o]
V = v_mag_pu*np.exp(1j*v_ang)
index = r_[:len(buses_o)]
#make sparse diagonal matrices
V_diag = csr_matrix((V,(index,index)))
V_norm_diag = csr_matrix((V/abs(V),(index,index)))
I_diag = csr_matrix((sub_network.Y*V,(index,index)))
dS_dVa = 1j*V_diag*np.conj(I_diag - sub_network.Y*V_diag)
dS_dVm = V_norm_diag*np.conj(I_diag) + V_diag * np.conj(sub_network.Y*V_norm_diag)
J00 = dS_dVa[1:,1:].real
J01 = dS_dVm[1:,1+len(sub_network.pvs):].real
J10 = dS_dVa[1+len(sub_network.pvs):,1:].imag
J11 = dS_dVm[1+len(sub_network.pvs):,1+len(sub_network.pvs):].imag
J = svstack([
shstack([J00, J01]),
shstack([J10, J11])
], format="csr")
return J
def equilibrium_matrix(C, xyz, free, rtype='array'):
r"""Construct the equilibrium matrix of a structural system.
Parameters
----------
C : array-like
Connectivity matrix (m x n).
xyz : array-like
Array of vertex coordinates (n x 3).
free : list
The index values of the free vertices.
rtype : {'array', 'csc', 'csr', 'coo', 'list'}
Format of the result.
Returns
-------
array-like
Constructed equilibrium matrix.
Notes
-----
Analysis of the equilibrium matrix reveals some of the properties of the
structural system, its size is (2ni x m) where ni is the number of free or
internal nodes. It is calculated by
.. math::
\mathbf{E}
=
\left[
\begin{array}{c}
\mathbf{C}^{\mathrm{T}}_{\mathrm{i}}\mathbf{U} \\[0.3em]
\hline \\[-0.7em]
\mathbf{C}^{\mathrm{T}}_{\mathrm{i}}\mathbf{V}
\end{array}
\right].
The matrix of vertex coordinates is vectorised to speed up the
calculations.
Examples
--------
>>> C = connectivity_matrix([[0, 1], [0, 2], [0, 3]])
>>> xyz = [[0, 0, 1], [0, 1, 0], [-1, -1, 0], [1, -1, 0]]
>>> equilibrium_matrix(C, xyz, [0], rtype='array')
[[ 0. 1. -1.]
[-1. 1. 1.]]
"""
xyz = asarray(xyz, dtype=float)
C = csr_matrix(C)
xy = xyz[:, :2]
uv = C.dot(xy)
U = diags([uv[:, 0].flatten()], [0])
V = diags([uv[:, 1].flatten()], [0])
Ct = C.transpose()
Cti = Ct[free, :]
E = svstack((Cti.dot(U), Cti.dot(V)))
return _return_matrix(E, rtype)
def dfdx(guess, distribute_slack=False, slack_weights=None):
last_pq = -1 if distribute_slack else None
network.buses_t.v_ang.loc[
now, sub_network.pvpqs] = guess[:len(sub_network.pvpqs)]
network.buses_t.v_mag_pu.loc[
now, sub_network.pqs] = guess[len(sub_network.pvpqs):last_pq]
v_mag_pu = network.buses_t.v_mag_pu.loc[now, buses_o]
v_ang = network.buses_t.v_ang.loc[now, buses_o]
V = v_mag_pu * np.exp(1j * v_ang)
index = r_[:len(buses_o)]
#make sparse diagonal matrices
V_diag = csr_matrix((V, (index, index)))
V_norm_diag = csr_matrix((V / abs(V), (index, index)))
I_diag = csr_matrix((sub_network.Y * V, (index, index)))
dS_dVa = 1j * V_diag * np.conj(I_diag - sub_network.Y * V_diag)
dS_dVm = V_norm_diag * np.conj(I_diag) + V_diag * np.conj(
sub_network.Y * V_norm_diag)
J10 = dS_dVa[1 + len(sub_network.pvs):, 1:].imag
J11 = dS_dVm[1 + len(sub_network.pvs):, 1 + len(sub_network.pvs):].imag
if distribute_slack:
J00 = dS_dVa[:, 1:].real
J01 = dS_dVm[:, 1 + len(sub_network.pvs):].real
J02 = csr_matrix(slack_weights, (1, 1 + len(sub_network.pvpqs))).T
J12 = csr_matrix((1, len(sub_network.pqs))).T
J_P_blocks = [J00, J01, J02]
J_Q_blocks = [J10, J11, J12]
else:
J00 = dS_dVa[1:, 1:].real
J01 = dS_dVm[1:, 1 + len(sub_network.pvs):].real
J_P_blocks = [J00, J01]
J_Q_blocks = [J10, J11]
J = svstack([shstack(J_P_blocks), shstack(J_Q_blocks)], format="csr")
return J
def _dfdx(guess, Y):
"""
Compute the Jacobian matrix.
Parameters
----------
guess : numpy.ndarray
The current v_guess for the roots of f(x), of size 2*(N-1), where elements
[0,...,N-2] are the nodal voltage angles \theta_i and [N-1,...,2(N-1)]
the nodal voltage magnitudes |V_i|. The slack bus variables are
excluded.
Y : scipy.sparse.csc_matrix
The nodal admittance matrix of shape (N, N) as a sparse matrix.
Returns
-------
J : scipy.sparse.csr_matrix
The Jacobian matrix as a sparse matrix.
"""
# Construct nodal voltage vector V, setting V_slack = 1+0j.
v = _construct_v_from_guess(guess)
index = np.array(range(len(v)))
# Construct sparse diagonal matrices.
v_diag = csr_matrix((v, (index, index)))
v_norm_diag = csr_matrix((v / abs(v), (index, index)))
i_diag = csr_matrix((Y * v, (index, index)))
# Construct the Jacobian matrix.
dS_dVa = 1j * v_diag * np.conj(i_diag - Y * v_diag) # dS / d \theta
dS_dVm = v_norm_diag * np.conj(i_diag) + v_diag * np.conj(
Y * v_norm_diag) # dS / d |V|
J00 = dS_dVa[1:, 1:].real
J01 = dS_dVm[1:, 1:].real
J10 = dS_dVa[1:, 1:].imag
J11 = dS_dVm[1:, 1:].imag
J = svstack([shstack([J00, J01]), shstack([J10, J11])], format='csr')
return J
def __init__(self, n, f, **kwargs):
"""
Initializer for the problem class.
The user will supply functions and vectors as keyword arguements. The
input vector x is assumed to be of length n.
Each function is assumed to take in only the vector x (with the
exception of the hessian function). Any user arguements must be wrapped
first instead.
Parameters
==========
n : integer, length of input vector for NLP problem
f : function
takes in x
returns scalar
Keyword args
============
f_x : function
takes in x
returns numpy column array of n x 1
x_l : a numpy column array of n x 1
x_u : a numpy column array of n x 1
and:
g : function
takes in x
returns numpy column array
h : function
takes in x
returns numpy column array
g_x : function
takes in x
returns scipy sparse matrix of n x len(g)
h_x : function
takes in x
returns scipy sparse matrix of n x len(h)
hessian : function
takes in x, v_g, v_h
where v are the lagrange multipliers of the lagrangian,
assumed to be of the form:
f(x) + v_g^T g + v_h^T h
returns scipy sparse matrix of n x n
or:
c : function
takes in x
returns numpy column array
c_x : function
takes in x
returns scipy sparse matrix of n x len(g)
c_l : numpy column array of len(c) x 1
c_u : numpy column array of len(c) x 1
hessian : function
takes in x, v
where v are the lagrange multipliers (as a numpy column
vector) of the lagrangian, assumed to be of the form:
f(x) + v^T c
returns scipy sparse matrix of n x n
Methods generated for the solver are:
f
f_x
c_e
c_i
A_e
A_i
H
"""
self.n = n
# First check to make sure problem hasn't been incorrectly supplied
combined = ['c', 'cl', 'cu', 'c_x']
separated = ['g', 'h', 'g_x', 'h_x']
# now check if components from either style are in the kwargs
check1 = max([(i in kwargs.keys()) for i in combined])
check2 = max([(i in kwargs.keys()) for i in separated])
# Raise error if 2 styles combined, or no constraints supplied
if check1 and check2:
raise ValueError('Problem supplied incorrectly (constraint style)')
elif check1:
style = 'c'
elif check2:
style = 's'
else:
raise ValueError('Only constrained problems supported')
# Also need to create settings for finite differencing
try:
# This is equivalent to max(f^y (x0)) where y = order + 1
# Used to calculate optimal finite difference step size
self._fdscale = kwargs['fin_diff_scale']
except:
self._fdscale = 1. / 3.
try: # Finite difference order - forward h, central h^2, central h^4
self._order = kwargs['fin_diff_order']
except:
self._order = 2
##########################################
# Functions are now going to be defined. #
##########################################
########################
# Common to both forms #
########################
# objective function definition
resh = lambda x: x.reshape(-1, 1)
self.f = lambda x: resh(f(x))
# objective function gradient
try:
self.f_x = kwargs['f_x']
except:
self.f_x = lambda x: self.approx_jacobian(x, f)
##################
# Separated form #
##################
if style == 's':
# equality constraint function
try:
self.c_e = kwargs['g']
except:
self.c_e = lambda x: self.empty_f(x)
# inequality constraint function
try:
self.c_i = kwargs['h']
except:
self.c_i = lambda x: self.empty_f(x)
# equality constraint gradient
try:
self.A_e = kwargs['g_x']
except:
self.A_e = lambda x: csc_matrix(self.approx_jacobian(x, self.c_e))
# inequality constraint gradient
try:
self.A_i = kwargs['h_x']
except:
self.A_i = lambda x: csc_matrix(self.approx_jacobian(x, self.c_i))
# hessian function
try:
self.hessian = kwargs['hessian']
except:
self.hessian = None
#################
# Combined form #
#################
else:
######## long and awkward... ###########
try:
xl = self.xl = kwargs['xl']
except:
xl = self.xl = ones((n, 1)) * -1e20
try:
xu = self.xu = kwargs['xu']
except:
xu = self.xu = ones((n, 1)) * 1e20
c = self.c = kwargs['c']
cl = self.cl = kwargs['cl']
cu = self.cu = kwargs['cu']
try:
c_x = self.c_x = kwargs['c_x']
except:
c_x = self.c_x = lambda x: csc_matrix(self.approx_jacobian(x, self.c))
o = n
mn = len(self.cl)
I = seye(o, o).tocsc()
(coo_xer, coo_xec, coo_xed, coo_xir, coo_xic, coo_xid, coo_xlr,
coo_xlc, coo_xld, coo_xur, coo_xuc, coo_xud, coo_cer, coo_cec,
coo_ced, coo_cir, coo_cic, coo_cid, coo_clr, coo_clc, coo_cld,
coo_cur, coo_cuc, coo_cud) = ([], [], [], [], [], [], [], [], [],
[], [], [], [], [], [], [], [], [],
[], [], [], [], [], [])
############## BOUNDS ################
xm = 0
xn = 0
for i in range(o):
if xl[i] == xu[i]:
coo_xer += [xm]
coo_xec += [i]
coo_xed += [1]
xm += 1
else:
coo_xir += [xn]
coo_xic += [i]
coo_xid += [1]
xn += 1
l = 0
u = 0
for i in range(xn):
if xl[coo_xic[i]] >= -1e19:
coo_xlr += [l]
coo_xlc += [coo_xic[i]]
coo_xld += [coo_xid[i]]
l += 1
if xu[coo_xic[i]] <= 1e19:
coo_xur += [u]
coo_xuc += [coo_xic[i]]
coo_xud += [coo_xid[i]]
u += 1
try:
Kxe = coo_matrix((coo_xed, (coo_xer, coo_xec)), shape=(xm, o)).tocsc()
except:
Kxe = None
try:
Kxl = coo_matrix((coo_xld, (coo_xlr, coo_xlc)), shape=(l, o)).tocsc()
except:
Kxl = None
try:
Kxu = coo_matrix((coo_xud, (coo_xur, coo_xuc)), shape=(u, o)).tocsc()
except:
Kxu = None
############## CONSTRAINTS ################
cm = 0
cn = 0
for i in range(mn):
if cl[i] == cu[i]:
coo_cer += [cm]
coo_cec += [i]
coo_ced += [1]
cm += 1
else:
coo_cir += [cn]
coo_cic += [i]
coo_cid += [1]
cn += 1
l = 0
u = 0
for i in range(cn):
if cl[coo_cic[i]] >= -1e19:
coo_clr += [l]
coo_clc += [coo_cic[i]]
coo_cld += [coo_cid[i]]
l += 1
if cu[coo_cic[i]] <= 1e19:
coo_cur += [u]
coo_cuc += [coo_cic[i]]
coo_cud += [coo_cid[i]]
u += 1
try:
Kce = coo_matrix((coo_ced, (coo_cer, coo_cec)), shape=(cm, mn)).tocsc()
except:
Kce = None
try:
Kcl = coo_matrix((coo_cld, (coo_clr, coo_clc)), shape=(l, mn)).tocsc()
except:
Kcl = None
try:
Kcu = coo_matrix((coo_cud, (coo_cur, coo_cuc)), shape=(u, mn)).tocsc()
except:
Kcu = None
############## COMBINING ################
# Equality
if (Kxe is not None) and (Kce is not None):
Ke = bmat([[Kxe, None],
[None, Kce]])
ce = vstack([Kxe * xl, Kce * cl])
eq = lambda x: Ke * vstack([resh(x), c(x)]) - ce
jeq = lambda x: (Ke * svstack([I, c_x(x)]))
num_x_eq = len(Kxe * xl)
elif Kxe is not None:
Ke = Kxe
ce = Kxe * xl
eq = lambda x: Ke * resh(x) - ce
jeq = lambda x: Ke
num_x_eq = len(Kxe * xl)
elif Kce is not None:
Ke = Kce
ce = Kce * cl
eq = lambda x: Ke * c(x) - ce
jeq = lambda x: (Ke * c_x(x))
num_x_eq = 0
else:
Ke = None
ce = None
eq = None
jeq = None
num_x_eq = 0
# Bounds
if (Kxl is not None) and (Kxu is not None):
Kiu = bmat([[-Kxl],
[ Kxu]])
ciu = vstack([Kxl * xl, -Kxu * xu])
elif Kxl is not None:
Kiu = -Kxl
ciu = Kxl * xl
elif Kxu is not None:
Kiu = Kxu
ciu = -Kxu * xu
else:
Kiu = None
ciu = None
# Constraints
if (Kcl is not None) and (Kcu is not None):
Kil = bmat([[-Kcl],
[ Kcu]])
cil = vstack([Kcl * cl, -Kcu * cu])
elif Kcl is not None:
Kil = -Kcl
cil = Kcl * cl
elif Kcu is not None:
Kil = Kcu
cil = -Kcu * cu
else:
Kil = None
cil = None
# Bounds + Constraints
if (Kiu is not None) and (Kil is not None):
Ki = bmat([[ Kiu, None],
[None, Kil]])
ci = vstack([ciu, cil])
ineq = lambda x: ci + Ki * vstack([resh(x), c(x)])
jineq = lambda x: (Ki * svstack([I, c_x(x)]))
num_x_bound = len(ciu)
elif Kil is not None:
Ki = Kil
ci = cil
ineq = lambda x: ci + Ki * c(x)
jineq = lambda x: (Ki * c_x(x))
num_x_bound = 0
elif Kiu is not None:
Ki = Kiu
ci = ciu
ineq = lambda x: ci + Ki * resh(x)
jineq = lambda x: Ki
num_x_bound = len(ciu)
else:
Ki = None
ci = None
ineq = None
jineq = None
num_x_bound = 0
############# HESSIAN ###################
try:
hess_func = kwargs['hessian']
self.c_hessian = hess_func
def hess(x, lam_e, lam_i):
lam_e = resh(lam_e)
lam_i = resh(lam_i)
lam = 0
try:
lam += Kce.transpose() * lam_e[num_x_eq:]
except:
pass
try:
lam += Kcl.transpose() * lam_i[num_x_bound:]
except:
pass
try:
lam += Kcu.transpose() * lam_i[num_x_bound:]
except:
pass
return hess_func(x, lam)
except:
hess = None
self.c_e = eq
self.c_i = ineq
self.A_e = jeq
self.A_i = jineq
self.hessian = hess
def __init__(self, n, f, **kwargs):
"""
Initializer for the problem class.
The user will supply functions and vectors as keyword arguements. The
input vector x is assumed to be of length n.
Each function is assumed to take in only the vector x (with the
exception of the hessian function). Any user arguements must be wrapped
first instead.
Parameters
==========
n : integer, length of input vector for NLP problem
f : function
takes in x
returns scalar
Keyword args
============
f_x : function
takes in x
returns numpy column array of n x 1
x_l : a numpy column array of n x 1
x_u : a numpy column array of n x 1
and:
g : function
takes in x
returns numpy column array
h : function
takes in x
returns numpy column array
g_x : function
takes in x
returns scipy sparse matrix of n x len(g)
h_x : function
takes in x
returns scipy sparse matrix of n x len(h)
hessian : function
takes in x, v_g, v_h
where v are the lagrange multipliers of the lagrangian,
assumed to be of the form:
f(x) + v_g^T g + v_h^T h
returns scipy sparse matrix of n x n
or:
c : function
takes in x
returns numpy column array
c_x : function
takes in x
returns scipy sparse matrix of n x len(g)
c_l : numpy column array of len(c) x 1
c_u : numpy column array of len(c) x 1
hessian : function
takes in x, v
where v are the lagrange multipliers (as a numpy column
vector) of the lagrangian, assumed to be of the form:
f(x) + v^T c
returns scipy sparse matrix of n x n
Methods generated for the solver are:
f
f_x
c_e
c_i
A_e
A_i
H
"""
self.n = n
# First check to make sure problem hasn't been incorrectly supplied
combined = ['c', 'cl', 'cu', 'c_x']
separated = ['g', 'h', 'g_x', 'h_x']
# now check if components from either style are in the kwargs
check1 = max([(i in kwargs.keys()) for i in combined])
check2 = max([(i in kwargs.keys()) for i in separated])
# Raise error if 2 styles combined, or no constraints supplied
if check1 and check2:
raise ValueError('Problem supplied incorrectly (constraint style)')
elif check1:
style = 'c'
elif check2:
style = 's'
else:
raise ValueError('Only constrained problems supported')
# Also need to create settings for finite differencing
try:
# This is equivalent to max(f^y (x0)) where y = order + 1
# Used to calculate optimal finite difference step size
self._fdscale = kwargs['fin_diff_scale']
except:
self._fdscale = 1. / 3.
try: # Finite difference order - forward h, central h^2, central h^4
self._order = kwargs['fin_diff_order']
except:
self._order = 2
##########################################
# Functions are now going to be defined. #
##########################################
########################
# Common to both forms #
########################
# objective function definition
resh = lambda x: x.reshape(-1, 1)
self.f = lambda x: resh(f(x))
# objective function gradient
try:
self.f_x = kwargs['f_x']
except:
self.f_x = lambda x: self.approx_jacobian(x, f)
##################
# Separated form #
##################
if style == 's':
# equality constraint function
try:
self.c_e = kwargs['g']
except:
self.c_e = lambda x: self.empty_f(x)
# inequality constraint function
try:
self.c_i = kwargs['h']
except:
self.c_i = lambda x: self.empty_f(x)
# equality constraint gradient
try:
self.A_e = kwargs['g_x']
except:
self.A_e = lambda x: csc_matrix(
self.approx_jacobian(x, self.c_e))
# inequality constraint gradient
try:
self.A_i = kwargs['h_x']
except:
self.A_i = lambda x: csc_matrix(
self.approx_jacobian(x, self.c_i))
# hessian function
try:
self.hessian = kwargs['hessian']
except:
self.hessian = None
#################
# Combined form #
#################
else:
######## long and awkward... ###########
try:
xl = self.xl = kwargs['xl']
except:
xl = self.xl = ones((n, 1)) * -1e20
try:
xu = self.xu = kwargs['xu']
except:
xu = self.xu = ones((n, 1)) * 1e20
c = self.c = kwargs['c']
cl = self.cl = kwargs['cl']
cu = self.cu = kwargs['cu']
try:
c_x = self.c_x = kwargs['c_x']
except:
c_x = self.c_x = lambda x: csc_matrix(
self.approx_jacobian(x, self.c))
o = n
mn = len(self.cl)
I = seye(o, o).tocsc()
(coo_xer, coo_xec, coo_xed, coo_xir, coo_xic, coo_xid, coo_xlr,
coo_xlc, coo_xld, coo_xur, coo_xuc, coo_xud, coo_cer, coo_cec,
coo_ced, coo_cir, coo_cic, coo_cid, coo_clr, coo_clc, coo_cld,
coo_cur, coo_cuc, coo_cud) = ([], [], [], [], [], [], [], [], [],
[], [], [], [], [], [], [], [], [],
[], [], [], [], [], [])
############## BOUNDS ################
xm = 0
xn = 0
for i in range(o):
if xl[i] == xu[i]:
coo_xer += [xm]
coo_xec += [i]
coo_xed += [1]
xm += 1
else:
coo_xir += [xn]
coo_xic += [i]
coo_xid += [1]
xn += 1
l = 0
u = 0
for i in range(xn):
if xl[coo_xic[i]] >= -1e19:
coo_xlr += [l]
coo_xlc += [coo_xic[i]]
coo_xld += [coo_xid[i]]
l += 1
if xu[coo_xic[i]] <= 1e19:
coo_xur += [u]
coo_xuc += [coo_xic[i]]
coo_xud += [coo_xid[i]]
u += 1
try:
Kxe = coo_matrix((coo_xed, (coo_xer, coo_xec)),
shape=(xm, o)).tocsc()
except:
Kxe = None
try:
Kxl = coo_matrix((coo_xld, (coo_xlr, coo_xlc)),
shape=(l, o)).tocsc()
except:
Kxl = None
try:
Kxu = coo_matrix((coo_xud, (coo_xur, coo_xuc)),
shape=(u, o)).tocsc()
except:
Kxu = None
############## CONSTRAINTS ################
cm = 0
cn = 0
for i in range(mn):
if cl[i] == cu[i]:
coo_cer += [cm]
coo_cec += [i]
coo_ced += [1]
cm += 1
else:
coo_cir += [cn]
coo_cic += [i]
coo_cid += [1]
cn += 1
l = 0
u = 0
for i in range(cn):
if cl[coo_cic[i]] >= -1e19:
coo_clr += [l]
coo_clc += [coo_cic[i]]
coo_cld += [coo_cid[i]]
l += 1
if cu[coo_cic[i]] <= 1e19:
coo_cur += [u]
coo_cuc += [coo_cic[i]]
coo_cud += [coo_cid[i]]
u += 1
try:
Kce = coo_matrix((coo_ced, (coo_cer, coo_cec)),
shape=(cm, mn)).tocsc()
except:
Kce = None
try:
Kcl = coo_matrix((coo_cld, (coo_clr, coo_clc)),
shape=(l, mn)).tocsc()
except:
Kcl = None
try:
Kcu = coo_matrix((coo_cud, (coo_cur, coo_cuc)),
shape=(u, mn)).tocsc()
except:
Kcu = None
############## COMBINING ################
# Equality
if (Kxe is not None) and (Kce is not None):
Ke = bmat([[Kxe, None], [None, Kce]])
ce = vstack([Kxe * xl, Kce * cl])
eq = lambda x: Ke * vstack([resh(x), c(x)]) - ce
jeq = lambda x: (Ke * svstack([I, c_x(x)]))
num_x_eq = len(Kxe * xl)
elif Kxe is not None:
Ke = Kxe
ce = Kxe * xl
eq = lambda x: Ke * resh(x) - ce
jeq = lambda x: Ke
num_x_eq = len(Kxe * xl)
elif Kce is not None:
Ke = Kce
ce = Kce * cl
eq = lambda x: Ke * c(x) - ce
jeq = lambda x: (Ke * c_x(x))
num_x_eq = 0
else:
Ke = None
ce = None
eq = None
jeq = None
num_x_eq = 0
# Bounds
if (Kxl is not None) and (Kxu is not None):
Kiu = bmat([[-Kxl], [Kxu]])
ciu = vstack([Kxl * xl, -Kxu * xu])
elif Kxl is not None:
Kiu = -Kxl
ciu = Kxl * xl
elif Kxu is not None:
Kiu = Kxu
ciu = -Kxu * xu
else:
Kiu = None
ciu = None
# Constraints
if (Kcl is not None) and (Kcu is not None):
Kil = bmat([[-Kcl], [Kcu]])
cil = vstack([Kcl * cl, -Kcu * cu])
elif Kcl is not None:
Kil = -Kcl
cil = Kcl * cl
elif Kcu is not None:
Kil = Kcu
cil = -Kcu * cu
else:
Kil = None
cil = None
# Bounds + Constraints
if (Kiu is not None) and (Kil is not None):
Ki = bmat([[Kiu, None], [None, Kil]])
ci = vstack([ciu, cil])
ineq = lambda x: ci + Ki * vstack([resh(x), c(x)])
jineq = lambda x: (Ki * svstack([I, c_x(x)]))
num_x_bound = len(ciu)
elif Kil is not None:
Ki = Kil
ci = cil
ineq = lambda x: ci + Ki * c(x)
jineq = lambda x: (Ki * c_x(x))
num_x_bound = 0
elif Kiu is not None:
Ki = Kiu
ci = ciu
ineq = lambda x: ci + Ki * resh(x)
jineq = lambda x: Ki
num_x_bound = len(ciu)
else:
Ki = None
ci = None
ineq = None
jineq = None
num_x_bound = 0
############# HESSIAN ###################
try:
hess_func = kwargs['hessian']
self.c_hessian = hess_func
def hess(x, lam_e, lam_i):
lam_e = resh(lam_e)
lam_i = resh(lam_i)
lam = 0
try:
lam += Kce.transpose() * lam_e[num_x_eq:]
except:
pass
try:
lam += Kcl.transpose() * lam_i[num_x_bound:]
except:
pass
try:
lam += Kcu.transpose() * lam_i[num_x_bound:]
except:
pass
return hess_func(x, lam)
except:
hess = None
self.c_e = eq
self.c_i = ineq
self.A_e = jeq
self.A_i = jineq
self.hessian = hess
