예제 #1
0
TEST(MathLib, LocalMatrixDeterminantInverse_Eigen)
{
    Eigen::Matrix3d fMat, fInv;
    fMat << 1, 2, 3,
            0, 1, 4,
            5, 6, 0;
    double fMat_det = MathLib::determinant(fMat);
    MathLib::inverse(fMat, fMat_det, fInv);

    Eigen::MatrixXd dMat(3,3), dInv(3,3);
    dMat = fMat;
    double dMat_det = MathLib::determinant(dMat);
    MathLib::inverse(dMat, dMat_det, dInv);

    ASSERT_NEAR(fMat_det, dMat_det, std::numeric_limits<double>::epsilon());
    ASSERT_ARRAY_NEAR(fInv.data(), dInv.data(), fInv.size(), std::numeric_limits<double>::epsilon());
}
예제 #2
0
void Inverse
( const DistMultiVec<Real>& x, 
        DistMultiVec<Real>& xInv,
  const DistMultiVec<Int>& orders, 
  const DistMultiVec<Int>& firstInds,
  Int cutoff )
{
    DEBUG_CSE

    DistMultiVec<Real> dInv(x.Comm());
    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 );
}
예제 #3
0
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 );
}