def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
A = arg_objs[0]
rows, cols = A.size
# Create the equivalent problem:
# minimize (trace(U) + trace(V))/2
# subject to:
# [U A; A.T V] is positive semidefinite
X = lu.create_var((rows+cols, rows+cols))
constraints = []
# Fix X using the fact that A must be affine by the DCP rules.
# X[0:rows,rows:rows+cols] == A
index.block_eq(X, A, constraints,
0, rows, rows, rows+cols)
half = lu.create_const(0.5, (1, 1))
trace = lu.mul_expr(half, lu.trace(X), (1, 1))
# Add SDP constraint.
return (trace, [SDP(X)] + constraints)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
A = arg_objs[0]
rows, cols = A.size
# Create the equivalent problem:
# minimize (trace(U) + trace(V))/2
# subject to:
# [U A; A.T V] is positive semidefinite
X = lu.create_var((rows + cols, rows + cols))
constraints = []
# Fix X using the fact that A must be affine by the DCP rules.
# X[0:rows,rows:rows+cols] == A
index.block_eq(X, A, constraints, 0, rows, rows, rows + cols)
half = lu.create_const(0.5, (1, 1))
trace = lu.mul_expr(half, lu.trace(X), (1, 1))
# Add SDP constraint.
return (trace, [SDP(X)] + constraints)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
X = arg_objs[0] # n by m matrix.
P = arg_objs[1] # n by n matrix.
n, m = X.size
# Create a matrix with Schur complement T - X.T*P^-1*X.
M = lu.create_var((n + m, n + m))
T = lu.create_var((m, m))
constraints = []
# Fix M using the fact that P must be affine by the DCP rules.
# M[0:n, 0:n] == P.
index.block_eq(M, P, constraints, 0, n, 0, n)
# M[0:n, n:n+m] == X
index.block_eq(M, X, constraints, 0, n, n, n + m)
# M[n:n+m, n:n+m] == T
index.block_eq(M, T, constraints, n, n + m, n, n + m)
# Add SDP constraint.
return (lu.trace(T), constraints + [SDP(M)])
def graph_implementation(arg_objs, size, data=None):
"""Sum the diagonal entries of the linear expression.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
return (lu.trace(arg_objs[0]), [])
def graph_implementation(arg_objs, size, data=None):
"""Sum the diagonal entries of the linear expression.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
return (lu.trace(arg_objs[0]), [])
def graph_implementation(self,
arg_objs,
shape: Tuple[int, ...],
data=None) -> Tuple[lo.LinOp, List[Constraint]]:
"""Sum the diagonal entries of the linear expression.
Parameters
----------
arg_objs : list
LinExpr for each argument.
shape : tuple
The shape of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
return (lu.trace(arg_objs[0]), [])
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
X = arg_objs[0] # n by m matrix.
P = arg_objs[1] # n by n matrix.
n, m = X.size
# Create a matrix with Schur complement T - X.T*P^-1*X.
M = lu.create_var((n + m, n + m))
T = lu.create_var((m, m))
constraints = []
# Fix M using the fact that P must be affine by the DCP rules.
# M[0:n, 0:n] == P.
index.block_eq(M, P, constraints,
0, n, 0, n)
# M[0:n, n:n+m] == X
index.block_eq(M, X, constraints,
0, n, n, n+m)
# M[n:n+m, n:n+m] == T
index.block_eq(M, T, constraints,
n, n+m, n, n+m)
# Add SDP constraint.
return (lu.trace(T), constraints + [SDP(M)])
