def MarkowitzOpt(mean, variance, covariance, interest_rate, min_return): n = mean.size + 1 # Number of assets (number of stocks + interest rate) mu = mean.values # Mean returns of n assets temp = np.full(n, interest_rate) temp[:-1] = mu mu = temp counter = 0 Sigma = np.zeros((n,n)) # Covariance of n assets for i in np.arange(n-1): for j in np.arange(i, n-1): if i==j: Sigma[i,j] = variance[i] else: Sigma[i,j] = covariance[counter] Sigma[j,i] = Sigma[i,j] counter+=1 Sigma = nearestPD(Sigma) # Converting covariance to the nearest positive-definite matrix # Ensuring feasability of inequality contraint if mu.max() < min_return: min_return = interest_rate w = Variable(n) # Portfolio allocation vector ret = mu.T* w risk = quad_form(w, Sigma) min_ret = Parameter(nonneg=True) min_ret.value = min_return prob = Problem(Minimize(risk), # Restricting to long-only portfolio [ret >= min_ret, sum(w) == 1, w >= 0]) prob.solve() return w.value
def mpt_opt(data, gamma_vec): NUM_SAMPLES = len(gamma_vec) w_vec_results = [None] * NUM_SAMPLES ret_results = np.zeros(NUM_SAMPLES) risk_results = np.zeros(NUM_SAMPLES) N = len(data) w_vec = Variable(N) mu_vec = np.array([np.mean(data[i]) for i in range(N)]) sigma_mat = np.cov(data) gamma = Parameter(nonneg=True) ret_val = mu_vec.T * w_vec risk_val = quad_form(w_vec, sigma_mat) # w^T Sigma w problem = Problem(Maximize(ret_val - gamma * risk_val), [sum(w_vec) == 1, w_vec >= 0]) for i, new_gamma in enumerate(gamma_vec): gamma.value = new_gamma problem.solve() w_vec_results[i] = w_vec.value ret_results[i] = ret_val.value risk_results[i] = sqrt(risk_val).value return (w_vec_results, ret_results, risk_results)
def __init__(self, name, c, A, b, dims): logging.info(name + " started") logging.info(name + "'s dims = " + str(dims)) self.name = name _, n = np.shape(A) self.n = n self.dims = dims self.xbar = Parameter(n, value=np.zeros(n)) self.xbar_old = Parameter(n, value=np.zeros(n)) self.u = Parameter(n, value=np.zeros(n)) self.x = Variable(n) self.c = c self.A = A self.b = b self.f = self.c.T @ self.x self.rho = constants.RHO self.f += (self.rho / 2) * sum_squares(self.x[self.dims] - self.xbar[self.dims] + self.u[self.dims]) logging.info(name + "'s f = " + str(self.f)) self.prox = Problem(Minimize(self.f), [self.A @ self.x == self.b, self.x >= 0]) self.history = { 'objval': [], 'r_norm': [], 'eps_pri': [], 's_norm': [], 'eps_dual': [], 'iter': [] } self.has_converged = False self.k = 0
def run_process(f, pipe): xbar = Parameter(n, value=np.zeros(n)) u = Parameter(n, value=np.zeros(n)) f += (rho/2)*sum_squares(x - xbar + u) prox = Problem(Minimize(f)) # ADMM loop. while True: prox.solve() pipe.send(x.value) xbar.value = pipe.recv() u.value += x.value - xbar.value
def __init__(self, circle_list, cij=None, obj='ar0', overlap=False, min_edge=2, verbose=False, **kwargs): """ Weighted Circle Packing Problem k - eps - min_edge - """ FormulationR2.__init__(self, circle_list, **kwargs) # solver and record args self._solve_args = {'method': 'dccp'} self._in_dict = {'k': 1, 'min_edge': min_edge, 'eps': 1e-2} # gather inputs X = circle_list.point_vars n = len(circle_list) cij = cij if cij is not None else np.ones((n, n)) # compute radii areas = np.asarray([x.area for x in circle_list.inputs]) r = np.sqrt(areas / np.pi) # * np.log(1 + areas / (min_area - min_edge ** 2)) self.r = r # indices of upper tris inds = np.triu_indices(n, 1) xi, xj = [x.tolist() for x in inds] # gather inputs weights = Parameter(shape=len(xi), value=cij[inds], name='cij', nonneg=True) radii = Parameter(shape=len(xi), value=r[xi] + r[xj], name='radii', nonneg=True) dists = cvx.norm(X[xi, :] - X[xj, :], 2, axis=1) # constraints self._constr.append(dists >= radii) # objective self._obj = Minimize(cvx.sum(cvx.multiply(weights, dists)))
def as_constraint(self, *args): """ Imagine there are bubbles of a fixed size floating about constraining the discrete space each face is given a coordinate X = 1, Xg is coordinate dist_real <= r X = 1, Xg is (0, 0) dist_fake <= r + 1000 note - 2-norm is SIGNIFICANTLY Faster than 1norm. """ N = len(self.space.faces) # centroids.shape[N, 2] centroids = np.asarray(self.space.faces.centroids) M = 2 * centroids.max() centroids = Parameter(shape=centroids.shape, value=centroids) px, py = self._p.X, self._p.Y C = [] for i, face_set in enumerate(self._actions): X = face_set.vars # selected faces cx = cvx.multiply(centroids[:, 0], X) cy = cvx.multiply(centroids[:, 1], X) Xg = cvx.vstack([cx, cy]).T v = cvx.vstack( [cvx.promote(px[i], (N, )), cvx.promote(py[i], (N, ))]).T C = [cvx.norm(v - Xg, 2, axis=1) <= self._r[i] + M * (1 - X)] return C
def as_constraint(self, *args): """ Imagine there are bubbles of a fixed size floating about constraining the discrete space each face is given a coordinate X = 1, Xg is coordinate dist_real <= r X = 1, Xg is (0, 0) dist_fake <= r + 1000 note - 2-norm is SIGNIFICANTLY Faster than 1norm. """ N = len(self.space.faces) X = self.stacked # selected faces M = 100 # upper bound # centroids.shape[N, 2] centroids = np.asarray(self.space.faces.centroids) centroids = Parameter(shape=centroids.shape, value=centroids) cx = cvx.multiply(centroids[:, 0], X) cy = cvx.multiply(centroids[:, 1], X) Xg = cvx.vstack([cx, cy]).T v = cvx.vstack( [cvx.promote(self._bx, (N, )), cvx.promote(self._by, (N, ))]).T C = [cvx.norm(v - Xg, 2, axis=1) <= self._r + M * (1 - X)] return C
def test_square_param(self): """Test issue arising with square plus parameter. """ a = Parameter(value=1) b = Variable() obj = Minimize(b**2 + abs(a)) prob = Problem(obj) prob.solve() self.assertAlmostEqual(obj.value, 1.0)
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 __init__(self, inputs, tgt, src=None, **kwargs): """ Convert a PointList to a segment list """ from src.cvopt.formulate.input_structs import PointList if isinstance(inputs, PointList): pass elif isinstance(inputs, int): inputs = PointList(inputs) FormulationR2.__init__(self, inputs, **kwargs) self._tgt_x = Parameter(value=tgt[0]) self._tgt_y = Parameter(value=tgt[1]) # source may not be an expression if src is None: self._src_x = Variable(pos=True, name='path_start_X') self._src_y = Variable(pos=True, name='path_start_Y') else: self._src_x = Parameter(value=src[0]) self._src_y = Parameter(value=src[1])
def branch_and_bound(n, A, B, c): from queue import PriorityQueue x = Variable(n) z = Variable(n) L = Parameter(n) U = Parameter(n) prob = Problem(Minimize(sum_squares(A*x + B*z - c)), [L <= z, z <= U]) visited = 0 best_z = None f_best = numpy.inf nodes = PriorityQueue() nodes.put((numpy.inf, 0, numpy.zeros(n), numpy.ones(n), 0)) while not nodes.empty(): visited += 1 # Evaluate the node with the lowest lower bound. _, _, L_val, U_val, idx = nodes.get() L.value = L_val U.value = U_val lower_bound = prob.solve() z_star = numpy.round(z.value) upper_bound = Problem(prob.objective, [z == z_star]).solve() f_best = min(f_best, upper_bound) if upper_bound == f_best: best_z = z_star # Add new nodes if not at a leaf and the branch cannot be pruned. if idx < n and lower_bound < f_best: for i in [0, 1]: L_val[idx] = U_val[idx] = i nodes.put((lower_bound, i, L_val.copy(), U_val.copy(), idx + 1)) #print("Nodes visited: %s out of %s" % (visited, 2**(n+1)-1)) return f_best, best_z
def test_parametric(self): """Test solve parametric problem vs full problem""" x = Variable() a = 10 # b_vec = [-10, -2., 2., 3., 10.] b_vec = [-10, -2.] for solver in self.solvers: print(solver) # Solve from scratch with no parameters x_full = [] obj_full = [] for b in b_vec: obj = Minimize(a * (x ** 2) + b * x) constraints = [0 <= x, x <= 1] prob = Problem(obj, constraints) prob.solve(solver=solver) x_full += [x.value] obj_full += [prob.value] # Solve parametric x_param = [] obj_param = [] b = Parameter() obj = Minimize(a * (x ** 2) + b * x) constraints = [0 <= x, x <= 1] prob = Problem(obj, constraints) for b_value in b_vec: b.value = b_value prob.solve(solver=solver) x_param += [x.value] obj_param += [prob.value] print(x_full) print(x_param) for i in range(len(b_vec)): self.assertItemsAlmostEqual(x_full[i], x_param[i], places=3) self.assertAlmostEqual(obj_full[i], obj_param[i])
def test_warm_start(self): """Test warm start. """ m = 200 n = 100 np.random.seed(1) A = np.random.randn(m, n) b = Parameter(m) # Construct the problem. x = Variable(n) prob = Problem(Minimize(sum_squares(A * x - b))) b.value = np.random.randn(m) result = prob.solve(warm_start=False) result2 = prob.solve(warm_start=True) self.assertAlmostEqual(result, result2) b.value = np.random.randn(m) result = prob.solve(warm_start=True) result2 = prob.solve(warm_start=False) self.assertAlmostEqual(result, result2) pass
def test_lasso(self): # Solve the following consensus problem using ADMM: # Minimize sum_squares(A*x - b) + gamma*norm(x,1) # Problem data. m = 100 n = 75 np.random.seed(1) A = np.random.randn(m,n) b = np.random.randn(m) # Separate penalty from regularizer. x = Variable(n) gamma = Parameter(nonneg = True) funcs = [sum_squares(A*x - b), gamma*norm(x,1)] p_list = [Problem(Minimize(f)) for f in funcs] probs = Problems(p_list) # Solve via consensus. gamma.value = 1.0 probs.solve(method = "consensus", rho_init = 1.0, max_iter = 50) print("Objective:", probs.value) print("Solution:", x.value)
def as_constraint(self, *args): """ todo notes : performance goes with N=6 is around 1 second. when constraints are tightened, goes to 5-6 seconds overall worse than circle-BoundedSet, but more consistent results maybe """ # centroids.shape[N, 2] cent = np.asarray(self.space.faces.centroids) centrx = Parameter(shape=cent[:, 0].shape, value=cent[:, 0], name='centrx') centry = Parameter(shape=cent[:, 1].shape, value=cent[:, 1], name='centry') bX, bY, bW, bH = self._boxlist.vars # base constraints - whatever for now C = [bW >= 1, bH >= 1] for i, face_set in enumerate(self._actions): X = face_set.vars # selected faces M = 100 # todo upper bound cx = cvx.multiply(centrx, X) cy = cvx.multiply(centry, X) # todo maybe lienaerize furda, or use true facemin and face max instead of centroid\ # # cx is within box if X_i = 1, C += [ bX[i] - bW[i] / 2 <= cx - 0.4 + M * (1 - X), bX[i] + bW[i] / 2 >= cx + 0.4, bY[i] - bH[i] / 2 <= cy - 0.4 + M * (1 - X), bY[i] + bH[i] / 2 >= cy + 0.4, ] return C
def compute_node_be_curvature(g, n=None, solver=None, solver_options={}, verbose=False): if n is not None: if g.degree[n] > 0: dgamma2 = construct_dgamma2(g, n, verbose) gammax = construct_gammax(g, n) dim_b1 = gammax.shape[0] dim_b2 = dgamma2.shape[0] dim_s2 = dgamma2.shape[0] - gammax.shape[0] if verbose: print('dim dgamma2 {0}; dim gammax {1}'.format(dim_b2, dim_b1)) gammax_ext = np.block([ [gammax, np.zeros((dim_b1, dim_s2))], [np.zeros((dim_b1, dim_s2)).T, np.zeros((dim_s2, dim_s2))], ]) a = Parameter((dim_b2, dim_b2), value=dgamma2) b = Parameter((dim_b2, dim_b2), value=gammax_ext) kappa = Variable() constraints = [(a - kappa * b >> 0)] objective = Maximize(kappa) prob = Problem(objective, constraints) if verbose: print(prob.status) prob.solve(solver=solver, **solver_options) if verbose: print(prob.status) return prob.value else: return 0 else: r = {n: compute_node_be_curvature(g, n, solver=solver, solver_options=solver_options, verbose=verbose) for n in g.nodes()} return r
def create_update(f): x = Variable(n) u = Parameter(n) def local_update(xbar): # Update u. if x.value is None: u.value = np.zeros(n) else: u.value += x.value - xbar # Update x. obj = f(x) + (rho / 2) * sum_squares(x - xbar + u) Problem(Minimize(obj)).solve() return x.value return local_update
def as_constraint(self, *args): """ for the faces of self.space, each partitioning X must have atleast 2 adjacent faces of same selection, or if X is 0, then +---+---+---+ | | 0 | | +---+---+---+ | A | A | 0 | +---+---+---+ | A | A | | +---+---+---+ self._actions is a Variable of size 'space.num_faces' """ N = len(self.space.faces) M = np.zeros((N, N), dtype=int) for k, vs in self.space.faces.to_faces.items(): M[list(vs), k] = 1 M = Parameter(shape=M.shape, value=M, symmetric=True, name='face_adj_mat') # print(M) C = [] for action in self._actions: # [ N, N ] @ [N, 1] -> N # 2 versions of this tested -> # v1 - use inverse directly to meet constraint this is empirically slower # this enforces connectivity C += [ self._c <= M @ action.vars + (self._c + 1) * (1 - action.vars) ] # ------------------ # v2 - use a slack variable either X or V # v = Variable(shape=N, boolean=True, name='indicator.{}.{}'.format(self.name, action.name)) # C += [ # 1 <= action.vars + v, # self._adj_lim <= M @ action.vars + 4 * v, # # self._adj_lim <= M @ (1 - action.vars) # ] return C
from multiprocessing import Pool import cvxopt import numpy from pylab import figure, show from cvxpy import Maximize, Parameter, Problem, Variable, norm2, square num_assets = 100 num_factors = 20 mu = cvxopt.exp(cvxopt.normal(num_assets)) F = cvxopt.normal(num_assets, num_factors) D = cvxopt.spdiag(cvxopt.uniform(num_assets)) x = Variable(num_assets) gamma = Parameter(nonneg=True) expected_return = mu.T * x variance = square(norm2(F.T * x)) + square(norm2(D * x)) # construct portfolio optimization problem *once* p = Problem(Maximize(expected_return - gamma * variance), [sum(x) == 1, x >= 0]) # encapsulate the allocation function def allocate(gamma_value): gamma.value = gamma_value p.solve() w = x.value expected_return, risk = mu.T * w, w.T * (F * F.T + D * D) * w
R = 0.1 * sparse.eye(1) # Initial and reference states x0 = np.array([0.1, 0.2]) # initial state # Reference input and states pref = 7.0 vref = 0 xref = np.array([pref, vref]) # reference state # Prediction horizon Np = 20 # Define problem u = Variable((nu, Np)) x = Variable((nx, Np + 1)) x_init = Parameter(nx) objective = 0 constraints = [x[:, 0] == x_init] for k in range(Np): objective += quad_form(x[:, k] - xref, Q) + quad_form( u[:, k], R) # objective function constraints += [x[:, k + 1] == Ad @ x[:, k] + Bd @ u[:, k] ] # system dynamics constraint constraints += [xmin <= x[:, k], x[:, k] <= xmax] # state interval constraint constraints += [umin <= u[:, k], u[:, k] <= umax] # input interval constraint objective += quad_form(x[:, Np] - xref, QN) prob = Problem(Minimize(objective), constraints) # Simulate in closed loop
def __init__(self, inputs, cvx_set, **kwargs): ObjectiveR2.__init__(self, inputs, **kwargs) shp = self.inputs.point_vars.shape self._cvx_set = Parameter(shape=shp, value=np.tile(cvx_set, (shp[0], 1)))
Qy = np.diag([20]) # or sparse.diags([]) QyN = np.diag([20]) # final cost #Qg = 0.01 * np.eye(1) QDg = 0.5 * sparse.eye(1) # Quadratic cost for Du0, Du1, ...., Du_N-1 # Initial and reference x0 = np.array([0.0, 0.0]) # initial state r = 1.0 # Reference output # Prediction horizon Np = 40 # Define problem u = Variable((nu, Np)) x = Variable((nx, Np + 1)) x_init = Parameter(nx) uminus1 = Parameter(nu) # input at time instant negative one (from previous MPC window or uinit in the first MPC window) objective = 0 constraints = [x[:, 0] == x_init] y = Cd @ x for k in range(Np): if k > 0: objective += quad_form(u[:, k] - u[:, k - 1], QDg) # \sum_{k=1}^{N_p-1} (uk - u_k-1)'QDu(uk - u_k-1) else: # at k = 0... # if uminus1[0] is not np.nan: # if there is an uold to be considered objective += quad_form(u[:, k] - uminus1, QDg) # ... penalize the variation of u0 with respect to uold objective += quad_form(y[:, k] - r, Qy) #objective += quad_form(u[:, k], Qg) # objective function
def calculate_portfolio(cvxtype, returns_function, long_only, exp_return, selected_solver, max_pos_size, ticker_list): assert cvxtype in ['minimize_risk','maximize_return'] """ Variables: mu is the vector of expected returns. sigma is the covariance matrix. gamma is a Parameter that trades off risk and return. x is a vector of stock holdings as fractions of total assets. """ gamma = Parameter(nonneg=True) gamma.value = 1 returns, stocks, betas = returns_function cov_mat = returns.cov() Sigma = cov_mat.values # np.asarray(cov_mat.values) w = Variable(len(cov_mat)) # #number of stocks for portfolio weights risk = quad_form(w, Sigma) #expected_variance => w.T*C*w = quad_form(w, C) # num_stocks = len(cov_mat) if cvxtype == 'minimize_risk': # Minimize portfolio risk / portfolio variance if long_only == True: prob = Problem(Minimize(risk), [sum(w) == 1, w > 0 ]) # Long only else: prob = Problem(Minimize(risk), [sum(w) == 1]) # Long / short elif cvxtype == 'maximize_return': # Maximize portfolio return given required level of risk #mu #Expected return for each instrument #expected_return = mu*x #risk = quad_form(x, sigma) #objective = Maximize(expected_return - gamma*risk) #p = Problem(objective, [sum_entries(x) == 1]) #result = p.solve() mu = np.array([exp_return]*len(cov_mat)) # mu is the vector of expected returns. expected_return = np.reshape(mu,(-1,1)).T * w # w is a vector of stock holdings as fractions of total assets. objective = Maximize(expected_return - gamma*risk) # Maximize(expected_return - expected_variance) if long_only == True: constraints = [sum(w) == 1, w > 0] else: #constraints=[sum_entries(w) == 1,w <= max_pos_size, w >= -max_pos_size] constraints=[sum(w) == 1] prob = Problem(objective, constraints) prob.solve(solver=selected_solver) weights = [] for weight in w.value: weights.append(float(weight)) if cvxtype == 'maximize_return': optimal_weights = {"Optimal expected return":expected_return.value, "Optimal portfolio weights":np.round(weights,2), "tickers": ticker_list, "Optimal risk": risk.value*100 } elif cvxtype == 'minimize_risk': optimal_weights = {"Optimal portfolio weights":np.round(weights,2), "tickers": ticker_list, "Optimal risk": risk.value*100 } return optimal_weights
from queue import PriorityQueue import numpy from cvxpy import Minimize, Parameter, Problem, sum_squares, Variable # Problem data. m = 25 n = 20 numpy.random.seed(1) A = numpy.matrix(numpy.random.randn(m, n)) b = numpy.matrix(numpy.random.randn(m, 1)) #b = A*numpy.random.uniform(-1, 1, size=(n, 1)) # Construct the problem. x = Variable(n) L = Parameter(n) U = Parameter(n) f = lambda x: sum_squares(A*x - b) prob = Problem(Minimize(f(x)), [L <= x, x <= U]) visited = 0 best_solution = numpy.inf best_x = 0 nodes = PriorityQueue() nodes.put((numpy.inf, 0, -numpy.ones(n), numpy.ones(n), 0)) while not nodes.empty(): visited += 1 # Evaluate the node with the lowest lower bound. _, _, L_val, U_val, idx = nodes.get() L.value = L_val
# Uses the Alternating Direction Method of Multipliers # with a (non-convex) cardinality constraint. # Generate data. np.random.seed(1) N = 50 M = 40 n = 10 data = [] for i in range(N): data += [(1, np.random.normal(1.0, 2.0, (n, 1)))] for i in range(M): data += [(-1, np.random.normal(-1.0, 2.0, (n, 1)))] # Construct problem. gamma = Parameter(nonneg=True) gamma.value = 0.1 # 'a' is a variable constrained to have at most 6 non-zero entries. a = Card(n, k=6) b = Variable() slack = [pos(1 - label*(sample.T*a - b)) for (label, sample) in data] objective = Minimize(norm(a, 2) + gamma*sum(slack)) p = Problem(objective) # Extensions can attach new solve methods to the CVXPY Problem class. p.solve(method="admm") # Count misclassifications. error = 0 for label, sample in data: if not label*(a.value.T*sample - b.value)[0] >= 0:
# (a figure is generated) # # Let p_star(epsilon) be the optimal value of the following problem: # minimize ||Ax + b + epsilon*d||_1 # Plots p_star(epsilon) versus epsilon and demonstrates the fact that it's # affine on an interval that includes epsilon = 0. # Input data m = 6 n = 3 A = cvxopt.matrix( [-2, 7, 1, -5, -1, 3, -7, 3, -5, -1, 4, -4, 1, 5, 5, 2, -5, -1], (m, n)) b = cvxopt.matrix([-4, 3, 9, 0, -11, 5], (m, 1)) d = cvxopt.matrix([-10, -13, -27, -10, -7, 14], (m, 1)) epsilon = Parameter() # The problem x = Variable(n) objective = Minimize(norm(A * x + b + epsilon * d, 1)) p = Problem(objective, []) # Assign a value to gamma and find the optimal x def get_p(e_value): epsilon.value = e_value result = p.solve() return result # Range of epsilon values
QDy = 10 * np.eye(ny) # penalty on Delta y Qrg = 10 * np.eye(ny) QDg = 100 * sparse.eye(ny) # Quadratic cost for Du0, Du1, ...., Du_N-1 # Initial state, reference, command x0 = np.array(2 * [0.0, 0.0]) # initial state y0 = Cd @ x0 # initial state gm1 = np.array(2 * [0.0]) # g at time -1, used for the constraint on Delta g # In[MPC Problem setup] g = Variable((ng, Np)) x = Variable((nx, Np)) eps_slack = Variable(ny) x_init = Parameter(nx) gminus1 = Parameter( ny ) # MPC command at time -1 (from previous MPC window or g_step_old for the first instant) yminus1 = Parameter( ny ) # system output at time -1 (from previous MPC window or y_step_old for the first instant) r = Parameter(ny) y = Cd @ x + Dd @ g # system output definition objective = 0.0 objective += quad_form(eps_slack, 1e4 * np.eye(ny)) # constraint violation penalty on slack constraints = [x[:, 0] == x_init] # initial state constraint constraints += [eps_slack >= 0.0] # slack positive constraint
# Taken from CVX website http://cvxr.com/cvx/examples/ # Exercise 5.1d: Sensitivity analysis for a simple QCQP # Ported from cvx matlab to cvxpy by Misrab Faizullah-Khan # Original comments below # Boyd & Vandenberghe, "Convex Optimization" # Joelle Skaf - 08/29/05 # (a figure is generated) # # Let p_star(u) denote the optimal value of: # minimize x^2 + 1 # s.t. (x-2)(x-2)<=u # Finds p_star(u) and plots it versus u u = Parameter() x = Variable() objective = Minimize(quad_form(x, 1) + 1) constraint = [quad_form(x, 1) - 6 * x + 8 <= u] p = Problem(objective, constraint) # Assign a value to gamma and find the optimal x. def get_x(u_value): u.value = u_value result = p.solve() return x.value u_values = np.linspace(-0.9, 10, num=50)
exact = 0.5 * np.sin(2 * np.pi * t / n) * np.sin(0.01 * t) corrupt = exact + 0.05 * np.random.randn(len(exact)) corrupt = cvxopt.matrix(corrupt) e = np.ones(n).T ee = np.column_stack((-e, e)).T D = sparse.spdiags(ee, range(-1, 1), n, n) D = D.todense() D = cvxopt.matrix(D) # Solve in parallel nopts = 10 lambdas = np.linspace(0, 50, nopts) # Frame the problem with a parameter lamb = Parameter(nonneg=True) x = Variable(n) p = Problem(Minimize(norm(x - corrupt) + norm(D * x) * lamb)) # For a value of lambda g, we solve the problem # Returns [ ||Dx||_2 and ||x-x_cor||_2 ] def get_value(g): lamb.value = g result = p.solve() return [np.linalg.norm(x.value - corrupt), np.linalg.norm(D * x.value)] pool = Pool(processes=4) # compute allocation in parallel norms1, norms2 = zip(*pool.map(get_value, lambdas))
Qy = np.diag(2 * [20]) # or sparse.diags([]) #QyN = np.diag(2*[20]) # final cost QDy = np.eye(ny) Qrg = 100 * np.eye(ny) QDg = 0.5 * sparse.eye(ny) # Quadratic cost for Du0, Du1, ...., Du_N-1 # Initial and reference x0 = np.array(2 * [0.0, 0.0]) # initial state # Prediction horizon Np = 40 # Define problem g = Variable((ng, Np)) x = Variable((nx, Np)) x_init = Parameter(nx) gminus1 = Parameter( ny ) # input at time instant negative one (from previous MPC window or uinit in the first MPC window) yminus1 = Parameter( ny ) # input at time instant negative one (from previous MPC window or uinit in the first MPC window) r = Parameter(ny) objective = 0.0 constraints = [x[:, 0] == x_init] y = Cd @ x + Dd @ g for k in range(Np): objective += quad_form(y[:, k] - r, Qy) # tracking cost objective += quad_form(g[:, k] - r, Qrg) # reference governor cost