How to use the cvxpy.quad_form function in cvxpy

def cvxpy_test():
    numpy.random.seed(1)
    n = 10
    mu = numpy.abs(numpy.random.randn(n, 1))
    Sigma = numpy.random.randn(n, n)
    Sigma = Sigma.T.dot(Sigma)

    w = cvxpy.Variable(n)
    gamma = cvxpy.Parameter(sign='positive')
    ret = mu.T*w
    risk = cvxpy.quad_form(w, Sigma)
    print ("csvpy test >>> ", cvxpy.Problem(cvxpy.Maximize(ret - gamma*risk),
               [cvxpy.sum_entries(w) == 1,
                w >= 0]))

def _fit_cvxpy(self, K, D, time):
        import cvxpy

        n_pairs = D.shape[0]

        a = cvxpy.Variable(shape=(n_pairs, 1))
        P = D.dot(D.dot(K).T).T
        q = D.dot(time)

        obj = cvxpy.Minimize(0.5 * cvxpy.quad_form(a, P) - a.T * q)
        assert obj.is_dcp()

        alpha = cvxpy.Parameter(nonneg=True, value=self.alpha)
        Dta = D.T.astype(P.dtype) * a  # cast constraints to correct type
        constraints = [a >= 0., -alpha <= Dta, Dta <= alpha]

        prob = cvxpy.Problem(obj, constraints)
        solver_opts = self._get_options_cvxpy()
        prob.solve(solver=cvxpy.settings.ECOS, **solver_opts)
        if prob.status != 'optimal':
            s = prob.solver_stats
            warnings.warn(('cvxpy solver {} did not converge after {} iterations: {}'.format(
                s.solver_name, s.num_iters, prob.status)),
                category=ConvergenceWarning,
                stacklevel=4)

def solve_qp(Q, q, G, h, n, C=None, d=None, init_x=None, solver=cp.GUROBI):
    x = cp.Variable(shape=(n, 1))
    #obj = cp.Minimize(cp.sum(cp.square(x)) + q.T * x)
    obj = cp.Minimize((1/2)*cp.quad_form(x, Q) + q.T @ x)

    if C is not None and d is not None:
        constraints = [G*x <= h, C*x == d]
    else:
        constraints = [G*x <= h]
    prob = cp.Problem(obj, constraints)

    if init_x is not None:
        x.value = init_x

    try:
        prob.solve(solver=solver)
    except cp.error.SolverError:
        try:
            prob.solve(solver=solver)
        except cp.error.SolverError as e:

cost = cvx.Minimize(J+J_tr+J_vc)
    
    # constraints
    constraints = []
    constraints += [x[k+1]==A[k]*x[k]+B[k]*u[k]+r[k]+v[k] for k in range(N)]
    constraints += [xi[k+1]==xi[k]+sum(u[k]) for k in range(N)]
    constraints += [x[0]==state_init,x[-1]==state_final,xi[0]==0]
    constraints += [(x[k][:3]-data['lm']['p']).T*I_e>=
                    cvx.norm(x[k][:3]-data['lm']['p'])*
                    np.cos(np.deg2rad(data['gamma']))
                    for k in range(N+1)]
    constraints += [u[k]<=data['t_pulse_max'] for k in range(N)]
    constraints += [u[k]>=u_lb[k] for k in range(N)]
    constraints += [u[k][i] == 0. for k in range(N) for i in range(n_u)
                    if i in data['thrusters_off']]
    constraints += [cvx.quad_form(x_hat[k+1]-x_prev_hat[k+1],np.eye(n_x))
                    <=eta_hat[k] for k in range(N)]
    constraints += [stc_lb[k][i]*u[k][i]==0
                    for k in range(N) for i in range(n_u)]
    constraints += [stc_q[k]*u[k][i]==0 for k in range(N)
                    for i in range(n_u) if 'p_f' in csm.i2thruster[i]]
    constraints += [stc_q[k+1]*
                    (tools.rqpmat(data['xf']['q'])[0].dot(np.diag([1,-1,-1,-1]))
                     *x[k][6:10]-np.cos(0.5*np.deg2rad(data['ang_app'])))<=0
                    for k in range(N)]

    data['lrtop'] = cvx.Problem(cost,constraints)

def _generate_cvxpy_problem(self):
        '''
        Generate QP problem
        '''

        x = cvxpy.Variable(self.n)
        y = cvxpy.Variable(self.k)

        # Create parameters m
        mu = cvxpy.Parameter(self.n)
        mu.value = self.mu

        objective = cvxpy.Minimize(cvxpy.quad_form(x, self.D) +
                                   cvxpy.quad_form(y, spa.eye(self.k)) +
                                   - 1 / self.gamma * (mu.T * x))
        constraints = [np.ones(self.n) * x == 1,
                       self.F.T * x == y,
                       0 <= x, x <= 1]
        problem = cvxpy.Problem(objective, constraints)

        return problem, mu

def gen_cvxpy_problem(self, n, m, qp_matrices):

        lambda_i = cvxpy.Parameter(sign="positive")
        x = cvxpy.Variable(n)
        y = cvxpy.Variable(m)
        t = cvxpy.Variable(n)

        objective = cvxpy.Minimize(cvxpy.quad_form(y, spa.eye(m))
                                   + lambda_i * (np.ones(n) * t))
        constraints = [y == qp_matrices.A_lasso * x - qp_matrices.b_lasso,
                       -t <= x, x <= t]
        problem = cvxpy.Problem(objective, constraints)
        return problem, lambda_i, (x, y, t)

:param target:
        :param time_horizon:
        :param verbose:
        :return:
        """
        assert len(initial_state) == self.state_len
        # Create variables
        x = opt.Variable(self.state_len, time_horizon + 1, name='states')
        u = opt.Variable(self.action_len, time_horizon, name='actions')

        # Loop through the entire time_horizon and append costs
        cost_function = []

        for t in range(time_horizon):
            # _cost = opt.norm(x[2, t + 1],2)*50 + opt.norm(x[3, t + 1],2)*50 + opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(u[:, t]-u[:, t-1], R*0.1)
            _cost = opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) + opt.quad_form(u[:, t], R) + opt.quad_form(
                u[:, t] - u[:, t - 1], R * 0.1)
            _constraints = [x[:, t + 1] == A * x[:, t] + B * u[:, t],
                            u[0, t] >= MAIN_ENGINE_POWER/1.8, u[0, t] <= MAIN_ENGINE_POWER / 1.05,
                            u[1, t] >= -SIDE_ENGINE_POWER, u[1, t] <= SIDE_ENGINE_POWER,
                            u[2, t] >= -self.angle_limit, u[2, t] <= self.angle_limit,
                            opt.norm(target[:, t + 1] - x[:, t + 1], 1) <= 0.01]

            cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=_constraints))

        # Add final cost
        problem = sum(cost_function)
        problem.constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 0.001,
                                x[:, 0] == initial_state]
        # Minimize Problem
        problem.solve(verbose=verbose, solver=opt.SCS)
        # u[0, :].value.A.flatten()

def _generate_cvxpy_problem(self):
        '''
        Generate QP problem
        '''

        n = self.n
        m = self.m
        x = cvxpy.Variable(n)
        t = cvxpy.Variable(m)

        objective = cvxpy.Minimize(.5 * cvxpy.quad_form(x, spa.eye(n))
                                   + .5 * self.gamma * np.ones(m) * t)
        constraints = [t >= spa.diags(self.b_svm).dot(self.A_svm) * x + 1,
                       t >= 0]

        problem = cvxpy.Problem(objective, constraints)

        return problem, (x, t)

def gen_cvxpy_problem(self, qp):
        (nx, nu) = self.problem.B.shape
        N = qp.n

        # Initial state
        x0 = cvxpy.Parameter(nx)

        # Problem
        p = self.problem

        # variables
        x = cvxpy.Variable(nx, N + 1)
        u = cvxpy.Variable(nu, N)

        # Objective
        cost = .5 * cvxpy.quad_form((x[:, N] - p.xr), p.QN)  # Final stage cost
        for i in range(N):
            cost += .5 * cvxpy.quad_form((x[:, i] - p.xr), p.Q)  # State cost
            cost += .5 * cvxpy.quad_form(u[:, i], p.R)  # Inpout cost
        objective = cvxpy.Minimize(cost)

        # Constraints
        constr = []
        # Linear Dynamics
        constr += [x[:, 0] == x0]
        for i in range(0, N):
            constr += [x[:, i+1] == p.A * x[:, i] + p.B * u[:, i]]

        # Terminal constraints
        if p.tmin is not None:
            constr += [p.tmin <= p.T * x[:, N], p.T * x[:, N] <= p.tmax]

costlist = 0.0
    constrlist = []

    for t in range(N):
        costlist += 0.5 * cvxpy.quad_form(x[:, t], Q)
        costlist += 0.5 * cvxpy.quad_form(u[:, t], R)

        constrlist += [x[:, t + 1] == A * x[:, t] + B * u[:, t]]

        if xmin is not None:
            constrlist += [x[:, t] >= xmin[:, 0]]
        if xmax is not None:
            constrlist += [x[:, t] <= xmax[:, 0]]

    costlist += 0.5 * cvxpy.quad_form(x[:, N], P)  # terminal cost
    if xmin is not None:
        constrlist += [x[:, N] >= xmin[:, 0]]
    if xmax is not None:
        constrlist += [x[:, N] <= xmax[:, 0]]

    if umax is not None:
        constrlist += [u <= umax]  # input constraints
    if umin is not None:
        constrlist += [u >= umin]  # input constraints

    constrlist += [x[:, 0] == x0[:, 0]]  # inital state constraints

    prob = cvxpy.Problem(cvxpy.Minimize(costlist), constrlist)

    prob.solve(verbose=True)