void PushInto
( ElementalMatrix<Real>& xPre,
const ElementalMatrix<Int>& ordersPre,
const ElementalMatrix<Int>& firstIndsPre,
Real minDist, Int cutoff )
{
DEBUG_ONLY(CSE cse("soc::PushInto"))
AssertSameGrids( xPre, ordersPre, firstIndsPre );
ElementalProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
DistMatrixReadWriteProxy<Real,Real,VC,STAR>
xProx( xPre, ctrl );
DistMatrixReadProxy<Int,Int,VC,STAR>
ordersProx( ordersPre, ctrl ),
firstIndsProx( firstIndsPre, ctrl );
auto& x = xProx.Get();
auto& orders = ordersProx.GetLocked();
auto& firstInds = firstIndsProx.GetLocked();
DistMatrix<Real,VC,STAR> d(x.Grid());
soc::LowerNorms( x, d, orders, firstInds, cutoff );
const Int localHeight = x.LocalHeight();
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Real x0 = x.GetLocal(iLoc,0);
const Real lowerNorm = d.GetLocal(iLoc,0);
if( i == firstInds.GetLocal(iLoc,0) && x0-lowerNorm < minDist )
x.UpdateLocal( iLoc, 0, minDist - (x0-lowerNorm) );
}
}
void MinEig
( const AbstractDistMatrix<Real>& xPre,
AbstractDistMatrix<Real>& minEigsPre,
const AbstractDistMatrix<Int>& orders,
const AbstractDistMatrix<Int>& firstIndsPre,
Int cutoff )
{
EL_DEBUG_CSE
AssertSameGrids( xPre, minEigsPre, orders, firstIndsPre );
ElementalProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
DistMatrixReadProxy<Real,Real,VC,STAR>
xProx( xPre, ctrl );
DistMatrixWriteProxy<Real,Real,VC,STAR>
minEigsProx( minEigsPre, ctrl );
DistMatrixReadProxy<Int,Int,VC,STAR>
firstIndsProx( firstIndsPre, ctrl );
auto& x = xProx.GetLocked();
auto& minEigs = minEigsProx.Get();
auto& firstInds = firstIndsProx.GetLocked();
const Int height = x.Height();
const Int localHeight = x.LocalHeight();
EL_DEBUG_ONLY(
if( x.Width() != 1 || orders.Width() != 1 || firstInds.Width() != 1 )
LogicError("x, orders, and firstInds should be column vectors");
if( orders.Height() != height || firstInds.Height() != height )
LogicError("orders and firstInds should be of the same height as x");
)
void Dets
( const ElementalMatrix<Real>& xPre,
ElementalMatrix<Real>& dPre,
const ElementalMatrix<Int>& ordersPre,
const ElementalMatrix<Int>& firstIndsPre,
Int cutoff )
{
DEBUG_CSE
AssertSameGrids( xPre, dPre, ordersPre, firstIndsPre );
ElementalProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
DistMatrixReadProxy<Real,Real,VC,STAR>
xProx( xPre, ctrl );
DistMatrixWriteProxy<Real,Real,VC,STAR>
dProx( dPre, ctrl );
DistMatrixReadProxy<Int,Int,VC,STAR>
ordersProx( ordersPre, ctrl ),
firstIndsProx( firstIndsPre, ctrl );
auto& x = xProx.GetLocked();
auto& d = dProx.Get();
auto& orders = ordersProx.GetLocked();
auto& firstInds = firstIndsProx.GetLocked();
auto Rx = x;
soc::Reflect( Rx, orders, firstInds );
soc::Dots( x, Rx, d, orders, firstInds, cutoff );
}
void LAV
( const AbstractDistMatrix<Real>& A,
const AbstractDistMatrix<Real>& b,
AbstractDistMatrix<Real>& xPre,
const lp::affine::Ctrl<Real>& ctrl )
{
EL_DEBUG_CSE
DistMatrixWriteProxy<Real,Real,MC,MR> xProx( xPre );
auto& x = xProx.Get();
const Int m = A.Height();
const Int n = A.Width();
const Grid& g = A.Grid();
const Range<Int> xInd(0,n), uInd(n,n+m), vInd(n+m,n+2*m);
DistMatrix<Real> c(g), AHat(g), G(g), h(g);
// c := [0;1;1]
// ============
Zeros( c, n+2*m, 1 );
auto cuv = c( IR(n,n+2*m), ALL );
Fill( cuv, Real(1) );
// \hat A := [A, I, -I]
// ====================
Zeros( AHat, m, n+2*m );
auto AHatx = AHat( IR(0,m), xInd );
auto AHatu = AHat( IR(0,m), uInd );
auto AHatv = AHat( IR(0,m), vInd );
AHatx = A;
FillDiagonal( AHatu, Real( 1) );
FillDiagonal( AHatv, Real(-1) );
// G := | 0 -I 0 |
// | 0 0 -I |
// ================
Zeros( G, 2*m, n+2*m );
auto Guv = G( IR(0,2*m), IR(n,n+2*m) );
FillDiagonal( Guv, Real(-1) );
// h := | 0 |
// | 0 |
// ==========
Zeros( h, 2*m, 1 );
// Solve the affine linear program
// ===============================
DistMatrix<Real> xHat(g), y(g), z(g), s(g);
LP( AHat, G, b, c, h, xHat, y, z, s, ctrl );
// Extract x
// =========
x = xHat( xInd, ALL );
}
void Apply
( const ElementalMatrix<Real>& xPre,
const ElementalMatrix<Real>& yPre,
ElementalMatrix<Real>& zPre,
const ElementalMatrix<Int>& ordersPre,
const ElementalMatrix<Int>& firstIndsPre,
Int cutoff )
{
DEBUG_ONLY(CSE cse("soc::Apply"))
AssertSameGrids( xPre, yPre, zPre, ordersPre, firstIndsPre );
ElementalProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
DistMatrixReadProxy<Real,Real,VC,STAR>
xProx( xPre, ctrl ),
yProx( yPre, ctrl );
DistMatrixWriteProxy<Real,Real,VC,STAR>
zProx( zPre, ctrl );
DistMatrixReadProxy<Int,Int,VC,STAR>
ordersProx( ordersPre, ctrl ),
firstIndsProx( firstIndsPre, ctrl );
auto& x = xProx.GetLocked();
auto& y = yProx.GetLocked();
auto& z = zProx.Get();
auto& orders = ordersProx.GetLocked();
auto& firstInds = firstIndsProx.GetLocked();
soc::Dots( x, y, z, orders, firstInds );
auto xRoots = x;
auto yRoots = y;
cone::Broadcast( xRoots, orders, firstInds );
cone::Broadcast( yRoots, orders, firstInds );
const Int localHeight = x.LocalHeight();
const Real* xBuf = x.LockedBuffer();
const Real* xRootBuf = xRoots.LockedBuffer();
const Real* yBuf = y.LockedBuffer();
const Real* yRootBuf = yRoots.LockedBuffer();
Real* zBuf = z.Buffer();
const Int* firstIndBuf = firstInds.LockedBuffer();
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = x.GlobalRow(iLoc);
const Int firstInd = firstIndBuf[iLoc];
if( i != firstInd )
zBuf[iLoc] += xRootBuf[iLoc]*yBuf[iLoc] + yRootBuf[iLoc]*xBuf[iLoc];
}
}
void Inverse
( const ElementalMatrix<Real>& xPre,
ElementalMatrix<Real>& xInvPre,
const ElementalMatrix<Int>& ordersPre,
const ElementalMatrix<Int>& firstIndsPre,
Int cutoff )
{
DEBUG_CSE
AssertSameGrids( xPre, xInvPre, ordersPre, firstIndsPre );
ElementalProxyCtrl ctrl;
ctrl.colConstrain = true;
ctrl.colAlign = 0;
DistMatrixReadProxy<Real,Real,VC,STAR>
xProx( xPre, ctrl );
DistMatrixWriteProxy<Real,Real,VC,STAR>
xInvProx( xInvPre, ctrl );
DistMatrixReadProxy<Int,Int,VC,STAR>
ordersProx( ordersPre, ctrl ),
firstIndsProx( firstIndsPre, ctrl );
auto& x = xProx.GetLocked();
auto& xInv = xInvProx.Get();
auto& orders = ordersProx.GetLocked();
auto& firstInds = firstIndsProx.GetLocked();
DistMatrix<Real,VC,STAR> dInv(x.Grid());
soc::Dets( x, dInv, orders, firstInds, cutoff );
cone::Broadcast( dInv, orders, firstInds );
auto entryInv = [=]( Real alpha ) { return Real(1)/alpha; };
EntrywiseMap( dInv, function<Real(Real)>(entryInv) );
auto Rx = x;
soc::Reflect( Rx, orders, firstInds );
Hadamard( dInv, Rx, xInv );
}
void IPM
( const AbstractDistMatrix<Real>& APre,
const AbstractDistMatrix<Real>& b,
Real lambda,
AbstractDistMatrix<Real>& xPre,
const qp::affine::Ctrl<Real>& ctrl )
{
EL_DEBUG_CSE
DistMatrixReadProxy<Real,Real,MC,MR> AProx( APre );
const auto& A = AProx.GetLocked();
DistMatrixWriteProxy<Real,Real,MC,MR> xProx( xPre );
auto& x = xProx.Get();
const Int m = A.Height();
const Int n = A.Width();
const Grid& g = A.Grid();
const Range<Int> uInd(0,n), vInd(n,2*n), rInd(2*n,2*n+m);
DistMatrix<Real> Q(g), c(g), AHat(g), G(g), h(g);
// Q := | 0 0 0 |
// | 0 0 0 |
// | 0 0 I |
// ==============
Zeros( Q, 2*n+m, 2*n+m );
auto Qrr = Q( rInd, rInd );
FillDiagonal( Qrr, Real(1) );
// c := lambda*[1;1;0]
// ===================
Zeros( c, 2*n+m, 1 );
auto cuv = c( IR(0,2*n), ALL );
Fill( cuv, lambda );
// \hat A := [A, -A, I]
// ====================
Zeros( AHat, m, 2*n+m );
auto AHatu = AHat( IR(0,m), uInd );
auto AHatv = AHat( IR(0,m), vInd );
auto AHatr = AHat( IR(0,m), rInd );
AHatu = A;
AHatv -= A;
FillDiagonal( AHatr, Real(1) );
// G := | -I 0 0 |
// | 0 -I 0 |
// ================
Zeros( G, 2*n, 2*n+m );
FillDiagonal( G, Real(-1) );
// h := 0
// ======
Zeros( h, 2*n, 1 );
// Solve the affine QP
// ===================
DistMatrix<Real> xHat(g), y(g), z(g), s(g);
QP( Q, AHat, G, b, c, h, xHat, y, z, s, ctrl );
// x := u - v
// ==========
x = xHat( uInd, ALL );
x -= xHat( vInd, ALL );
}
void RLS
( const ElementalMatrix<Real>& APre,
const ElementalMatrix<Real>& bPre,
Real rho,
ElementalMatrix<Real>& xPre,
const socp::affine::Ctrl<Real>& ctrl )
{
DEBUG_CSE
DistMatrixReadProxy<Real,Real,MC,MR>
AProx( APre ),
bProx( bPre );
DistMatrixWriteProxy<Real,Real,MC,MR>
xProx( xPre );
auto& A = AProx.GetLocked();
auto& b = bProx.GetLocked();
auto& x = xProx.Get();
const Int m = A.Height();
const Int n = A.Width();
const Grid& g = A.Grid();
DistMatrix<Int,VC,STAR> orders(g), firstInds(g);
Zeros( orders, m+n+3, 1 );
Zeros( firstInds, m+n+3, 1 );
{
const Int localHeight = orders.LocalHeight();
for( Int iLoc=0; iLoc<localHeight; ++iLoc )
{
const Int i = orders.GlobalRow(iLoc);
if( i < m+1 )
{
orders.SetLocal( iLoc, 0, m+1 );
firstInds.SetLocal( iLoc, 0, 0 );
}
else
{
orders.SetLocal( iLoc, 0, n+2 );
firstInds.SetLocal( iLoc, 0, m+1 );
}
}
}
// G := | -1 0 0 |
// | 0 0 A |
// | 0 -1 0 |
// | 0 0 -I |
// | 0 0 0 |
DistMatrix<Real> G(g);
{
Zeros( G, m+n+3, n+2 );
G.Set( 0, 0, -1 );
auto GA = G( IR(1,m+1), IR(2,n+2) );
GA = A;
G.Set( m+1, 1, -1 );
auto GI = G( IR(m+2,m+n+2), IR(2,n+2) );
Identity( GI, n, n );
GI *= -1;
}
// h := | 0 |
// | b |
// | 0 |
// | 0 |
// | 1 |
DistMatrix<Real> h(g);
Zeros( h, m+n+3, 1 );
auto hb = h( IR(1,m+1), ALL );
hb = b;
h.Set( END, 0, 1 );
// c := [1; rho; 0]
DistMatrix<Real> c(g);
Zeros( c, n+2, 1 );
c.Set( 0, 0, 1 );
c.Set( 1, 0, rho );
DistMatrix<Real> AHat(g), bHat(g);
Zeros( AHat, 0, n+2 );
Zeros( bHat, 0, 1 );
DistMatrix<Real> xHat(g), y(g), z(g), s(g);
SOCP( AHat, G, bHat, c, h, orders, firstInds, xHat, y, z, s, ctrl );
x = xHat( IR(2,END), ALL );
}