Example #1
0
void TestGemv
( El::Int height,
  El::Int width,
  El::Orientation orientation,
  const El::Grid& grid,
  bool print )
{
    El::DistMatrix<Field> A(grid);
    El::Uniform( A, height, width );

    // Draw the entries of the original x and y from uniform distributions
    // over the complex unit ball
    El::DistMatrix<Field,El::VC,El::STAR> x(grid), y(grid);
    if( orientation == El::NORMAL )
    {
        El::Uniform( x, width, 1 );
        El::Uniform( y, height, 1 );
    }
    else
    {
        El::Uniform( x, height, 1 );
        El::Uniform( y, width, 1 );
    }

    if( print )
    {
        El::Print( A, "A" );
        El::Print( x, "x" );
        El::Print( y, "y" );
    }

    // Run the matrix-vector product
    if( grid.Rank() == 0 )
        El::Output("Starting Gemv (with Field=",El::TypeName<Field>(),")");
    El::Timer gemvElem;
    gemvElem.Start();
    // Form y := 3 A x + 4 y
    El::Gemv( orientation, Field(3), A, x, Field(4), y );
    gemvElem.Stop();
    if( grid.Rank() == 0 )
        El::Output("  Time: ",gemvElem.Total());

    if( print )
    {
        if( orientation == El::NORMAL )
            El::Print( y, "y := 3 A x + 4 y" );
        else
            El::Print( y, "y := 3 A^H x + 4 y" );
    }
}
Example #2
0
int
main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );
    El::mpi::Comm comm = El::mpi::COMM_WORLD;

    try
    {
        typedef double Real;
        typedef El::Complex<Real> Scalar;

        const El::Int m = El::Input("--height","height of matrix",100);
        const El::Int n = El::Input("--width","width of matrix",100);
        const bool print = El::Input("--print","print matrices?",false);
        El::ProcessInput();
        El::PrintInputReport();

        El::DistMatrix<Scalar> A;
        El::Uniform( A, m, n );

        El::Timer timer;
        // Compute the pseudoinverseof A (but do not overwrite A)
        El::DistMatrix<Scalar> pinvA( A );
        if( El::mpi::Rank(comm) == 0 )
            timer.Start();
        El::Pseudoinverse( pinvA );
        if( El::mpi::Rank(comm) == 0 )
            timer.Stop();
        if( print )
        {
            El::Print( A, "A" );
            El::Print( pinvA, "pinv(A)" );
        }

        const Real frobA = El::FrobeniusNorm( A );
        const Real frobPinvA = El::FrobeniusNorm( pinvA );

        if( El::mpi::Rank(comm) == 0 )
        {
            El::Output("PseudoInverse time: ",timer.Total()," secs");
            El::Output
            ("||   A     ||_F = ",frobA,"\n",
             "|| pinv(A) ||_F = ",frobPinvA,"\n");
        }
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}
Example #3
0
int main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );

    try
    {
        typedef double Real;
        typedef El::Complex<Real> Scalar;

        const El::Int m = El::Input("--height","height of matrix",20);
        const El::Int n = El::Input("--width","width of matrix",100);
        const El::Int r = El::Input("--rank","rank of matrix",5);
        const El::Int maxSteps =
          El::Input("--maxSteps","max # of steps of QR",10);
        const Real tol = El::Input("--tol","tolerance for ID",Real(-1));
        const bool print = El::Input("--print","print matrices?",false);
        const bool smallestFirst =
          El::Input("--smallestFirst","smallest norm first?",false);
        El::ProcessInput();
        El::PrintInputReport();

        El::mpi::Comm comm = El::mpi::COMM_WORLD;

        const El::Grid& grid = El::Grid::Default();
        El::DistMatrix<Scalar> U(grid), V(grid), A(grid);
        El::Uniform( U, m, r );
        El::Uniform( V, n, r );
        El::Gemm( El::NORMAL, El::ADJOINT, Scalar(1), U, V, A );
        const Real frobA = El::FrobeniusNorm( A );
        if( print )
            El::Print( A, "A" );

        El::DistPermutation Omega(grid);
        El::DistMatrix<Scalar,El::STAR,El::VR> Z(grid);
        El::QRCtrl<Real> ctrl;
        ctrl.boundRank = true;
        ctrl.maxRank = maxSteps;
        if( tol != -1. )
        {
            ctrl.adaptive = true;
            ctrl.tol = tol;
        }
        ctrl.smallestFirst = smallestFirst;
        El::Timer timer;
        if( El::mpi::Rank(comm) == 0 )
            timer.Start();
        El::ID( A, Omega, Z, ctrl );
        if( El::mpi::Rank(comm) == 0 )
            timer.Stop();
        const El::Int rank = Z.Height();
        if( print )
        {
            El::DistMatrix<El::Int> OmegaFull(grid);
            Omega.ExplicitMatrix( OmegaFull );
            El::Print( OmegaFull, "Omega" );
            El::Print( Z, "Z" );
        }

        // Pivot A and form the matrix of its (hopefully) dominant columns
        El::Timer permTimer("permTimer");
        permTimer.Start();
        Omega.PermuteCols( A );
        permTimer.Stop();

        auto hatA( A );
        hatA.Resize( m, rank );
        if( print )
        {
            El::Print( A, "A Omega^T" );
            El::Print( hatA, "\\hat{A}" );
        }

        // Check || A Omega^T - \hat{A} [I, Z] ||_F / || A ||_F
        El::DistMatrix<Scalar> AL(grid), AR(grid);
        El::PartitionRight( A, AL, AR, rank );
        El::Zero( AL );
        {
            El::DistMatrix<Scalar,El::MC,El::STAR> hatA_MC_STAR(grid);
            El::DistMatrix<Scalar,El::STAR,El::MR> Z_STAR_MR(grid);
            hatA_MC_STAR.AlignWith( AR );
            Z_STAR_MR.AlignWith( AR );
            hatA_MC_STAR = hatA;
            Z_STAR_MR = Z;
            El::LocalGemm
            ( El::NORMAL, El::NORMAL,
              Scalar(-1), hatA_MC_STAR, Z_STAR_MR, Scalar(1), AR );
        }
        const Real frobError = El::FrobeniusNorm( A );
        if( print )
            El::Print( A, "A Omega^T - \\hat{A} [I, Z]" );

        if( El::mpi::Rank(comm) == 0 )
        {
            El::Output("  ID time: ",timer.Total()," secs");
            El::Output
            ("|| A ||_F = ",frobA,"\n",
             "|| A Omega^T - \\hat{A} [I, Z] ||_F / || A ||_F = ",
             frobError/frobA);
        }
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}
Example #4
0
int main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );

    try
    {
        const El::Int n = El::Input("--n","problem size",200);
        const El::Int maxIter =
          El::Input("--maxIter","maximum # of iter's",500);
        const Real lb = El::Input("--lb","lower bound for x",0.5);
        const Real ub = El::Input("--ub","upper bound for x",1.0);
        const Real lbEig = El::Input("--lbEig","spectral lower bound",1.);
        const Real ubEig = El::Input("--ubEig","spectral upper bound",2.);
        const Real rho = El::Input("--rho","augmented Lagrangian param.",1.);
        const Real alpha = El::Input("--alpha","over-relaxation",1.2);
        const Real absTol = El::Input("--absTol","absolute tolerance",1e-6);
        const Real relTol = El::Input("--relTol","relative tolerance",1e-4);
        const bool inv = El::Input("--inv","form inv(LU) to avoid trsv?",true);
        const bool progress = El::Input("--progress","print progress?",true);
        const bool display = El::Input("--display","display matrices?",false);
        const bool print = El::Input("--print","print matrices",false);
        El::ProcessInput();
        El::PrintInputReport();

        El::ADMMCtrl<Real> ctrl;
        ctrl.rho = rho;
        ctrl.alpha = alpha;
        ctrl.maxIter = maxIter;
        ctrl.absTol = absTol;
        ctrl.relTol = relTol;
        ctrl.inv = inv;
        ctrl.print = progress;

        El::DistMatrix<Real> Q, c, xTrue;
        El::HermitianUniformSpectrum( Q, n, lbEig, ubEig );
        // Alternate the entries of xTrue between ub and lb
        El::Zeros( xTrue, n, 1 );
        if( xTrue.LocalWidth() == 1 )
            for( El::Int iLoc=0; iLoc<xTrue.LocalHeight(); ++iLoc )
                xTrue.SetLocal( iLoc, 0,
                    ( xTrue.GlobalRow(iLoc)%2==0 ? lb : ub ) );
        // Set c := - Q xTrue - du + dl
        El::Zeros( c, n, 1 );
        El::Hemv( El::LOWER, Real(-1), Q, xTrue, Real(0), c );
        if( c.LocalWidth() == 1 )
            for( El::Int iLoc=0; iLoc<c.LocalHeight(); ++iLoc )
                c.UpdateLocal( iLoc, 0,
                    ( c.GlobalRow(iLoc)%2==0 ? 0.5 : -0.5 ) );
        if( print )
        {
            El::Print( Q, "Q" );
            El::Print( c, "c" );
            El::Print( xTrue, "xTrue" );
        }
        if( display )
            El::Display( Q, "Q" );

        El::Timer timer;
        El::DistMatrix<Real> z;
        if( El::mpi::Rank() == 0 )
            timer.Start();
        El::qp::box::ADMM( Q, c, lb, ub, z, ctrl );
        if( El::mpi::Rank() == 0 )
            timer.Stop();

        if( print )
            El::Print( z, "z" );
        if( El::mpi::Rank() == 0 )
            El::Output("QPBox time: ",timer.Total(),"secs");
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}
Example #5
0
int
main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );

    try
    {
        const El::Int m = El::Input("--m","height of matrix",100);
        const El::Int n = El::Input("--n","width of matrix",200);
        // TODO(poulson): Add options for controlling IPM
        const El::Int maxIter =
          El::Input("--maxIter","maximum # of iter's",500);
        const Real lambda = El::Input("--lambda","DS parameter",0.5);
        const bool display = El::Input("--display","display matrices?",false);
        const bool print = El::Input("--print","print matrices",false);
        El::ProcessInput();
        El::PrintInputReport();

        El::SparseMatrix<Real> A;
        El::Matrix<Real> b, xTrue;
        El::Identity( A, m, n );
        El::Uniform( b, m, 1 );
        if( print )
        {
            El::Print( A, "A" );
            El::Print( b, "b" );
        }
        if( display )
            El::Display( A, "A" );

        El::lp::affine::Ctrl<Real> affineCtrl; 
        affineCtrl.mehrotraCtrl.print = true;

        El::Matrix<Real> x;
        El::Timer timer;
        if( El::mpi::Rank() == 0 )
            timer.Start();
        El::DS( A, b, lambda, x, affineCtrl );
        if( El::mpi::Rank() == 0 )
            timer.Stop();
        if( print )
            El::Print( x, "x" );
        const El::Int xZeroNorm = El::ZeroNorm( x );
        if( El::mpi::Rank() == 0 )
        {
            El::Output("Dantzig Selector time: ",timer.Total()," secs");
            El::Output("|| x ||_0 = ",xZeroNorm);
        }
        SoftThreshold( x, El::Sqrt(El::limits::Epsilon<Real>()) );
        if( print )
            El::Print( x, "xThresh" );
        const El::Int xZeroNormThresh = El::ZeroNorm( x );
        if( El::mpi::Rank() == 0 )
        {
            El::Output("|| xThresh ||_0 = ",xZeroNormThresh);
        }
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}
Example #6
0
int
main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );

    try
    {
        const El::Int n = El::Input("--size","width of matrix",100);
        const bool display = El::Input("--display","display matrices?",false);
        const bool print = El::Input("--print","print matrices?",false);
        const bool smallestFirst =
          El::Input("--smallestFirst","smallest norm first?",false);
        El::ProcessInput();
        El::PrintInputReport();
        const El::Int m = n;

        El::QRCtrl<double> ctrl;
        ctrl.smallestFirst = smallestFirst;

        El::DistMatrix<El::Complex<double>> A;
        El::GKS( A, n );
        const double frobA = El::FrobeniusNorm( A );
        if( display )
            El::Display( A, "A" );
        if( print )
            El::Print( A, "A" );

        // Compute the pivoted QR decomposition of A, but do not overwrite A
        auto QRPiv( A );
        El::DistMatrix<El::Complex<double>> householderScalarsPiv;
        El::DistMatrix<double> signaturePiv;
        El::DistPermutation Omega;
        El::Timer PQRtimer;
        if( El::mpi::Rank() == 0 )
            PQRtimer.Start();
        El::QR( QRPiv, householderScalarsPiv, signaturePiv, Omega );
        if( El::mpi::Rank() == 0 )
            PQRtimer.Stop();
        if( display )
        {
            El::Display( QRPiv, "QRPiv" );
            El::Display( householderScalarsPiv, "householderScalarsPiv" );
            El::Display( signaturePiv, "signaturePiv" );

            El::DistMatrix<El::Int> OmegaFull;
            Omega.ExplicitMatrix( OmegaFull );
            El::Display( OmegaFull, "Omega" );
        }
        if( print )
        {
            El::Print( QRPiv, "QRPiv" );
            El::Print( householderScalarsPiv, "householderScalarsPiv" );
            El::Print( signaturePiv, "signaturePiv" );

            El::DistMatrix<El::Int> OmegaFull;
            Omega.ExplicitMatrix( OmegaFull );
            El::Print( OmegaFull, "Omega" );
        }

        // Compute the standard QR decomposition of A
        auto QRNoPiv( A );
        El::DistMatrix<El::Complex<double>> householderScalarsNoPiv;
        El::DistMatrix<double> signatureNoPiv;
        El::Timer QRtimer;
        if( El::mpi::Rank() == 0 )
            QRtimer.Start();
        El::QR( QRNoPiv, householderScalarsNoPiv, signatureNoPiv );
        if( El::mpi::Rank() == 0 )
            QRtimer.Start();
        if( display )
        {
            El::Display( QRNoPiv, "QRNoPiv" );
            El::Display( householderScalarsNoPiv, "householderScalarsNoPiv" );
            El::Display( signatureNoPiv, "signatureNoPiv" );
        }
        if( print )
        {
            El::Print( QRNoPiv, "QRNoPiv" );
            El::Print( householderScalarsNoPiv, "householderScalarsNoPiv" );
            El::Print( signatureNoPiv, "signatureNoPiv" );
        }

        // Check the error in the pivoted QR factorization,
        // || A Omega^T - Q R ||_F / || A ||_F
        auto E( QRPiv );
        El::MakeTrapezoidal( El::UPPER, E );
        El::qr::ApplyQ
        ( El::LEFT, El::NORMAL, QRPiv, householderScalarsPiv, signaturePiv, E );
        Omega.InversePermuteCols( E );
        E -= A;
        const double frobQRPiv = El::FrobeniusNorm( E );
        if( display )
            El::Display( E, "A P - Q R" );
        if( print )
            El::Print( E, "A P - Q R" );

        // Check the error in the standard QR factorization,
        // || A - Q R ||_F / || A ||_F
        E = QRNoPiv;
        El::MakeTrapezoidal( El::UPPER, E );
        El::qr::ApplyQ
        ( El::LEFT, El::NORMAL,
          QRNoPiv, householderScalarsNoPiv, signatureNoPiv, E );
        E -= A;
        const double frobQRNoPiv = El::FrobeniusNorm( E );
        if( display )
            El::Display( E, "A - Q R" );
        if( print )
            El::Print( E, "A - Q R" );

        // Check orthogonality of pivoted Q, || I - Q^H Q ||_F / || A ||_F
        El::Identity( E, m, n );
        El::qr::ApplyQ
        ( El::LEFT, El::NORMAL,
          QRPiv, householderScalarsPiv, signaturePiv, E );
        El::qr::ApplyQ
        ( El::LEFT, El::ADJOINT,
          QRPiv, householderScalarsPiv, signaturePiv, E );
        const El::Int k = El::Min(m,n);
        auto EUpper = E( El::IR(0,k), El::IR(0,k) );
        El::ShiftDiagonal( EUpper, El::Complex<double>(-1) );
        const double frobOrthogPiv = El::FrobeniusNorm( EUpper );
        if( display )
            El::Display( E, "pivoted I - Q^H Q" );
        if( print )
            El::Print( E, "pivoted I - Q^H Q" );

        // Check orthogonality of unpivoted Q, || I - Q^H Q ||_F / || A ||_F
        El::Identity( E, m, n );
        El::qr::ApplyQ
        ( El::LEFT, El::NORMAL,
          QRPiv, householderScalarsPiv, signaturePiv, E );
        El::qr::ApplyQ
        ( El::LEFT, El::ADJOINT,
          QRPiv, householderScalarsPiv, signaturePiv, E );
        EUpper = E( El::IR(0,k), El::IR(0,k) );
        El::ShiftDiagonal( EUpper, El::Complex<double>(-1) );
        const double frobOrthogNoPiv = El::FrobeniusNorm( EUpper );
        if( display )
            El::Display( E, "unpivoted I - Q^H Q" );
        if( print )
            El::Print( E, "unpivoted I - Q^H Q" );

        if( El::mpi::Rank() == 0 )
        {
            El::Output("Pivot QR time: ",PQRtimer.Total()," secs\n",
                       "      QR time: ",QRtimer.Total()," secs");
            El::Output
            ("|| A ||_F = ",frobA,"\n\n",
             "With pivoting: \n",
             "    || A P - Q R ||_F / || A ||_F = ",frobQRPiv/frobA,"\n",
             "    || I - Q^H Q ||_F / || A ||_F = ",frobOrthogPiv/frobA,"\n\n",
             "Without pivoting: \n",
             "    || A - Q R ||_F / || A ||_F = ",frobQRNoPiv/frobA,"\n",
             "    || I - Q^H Q ||_F / || A ||_F = ",frobOrthogNoPiv/frobA,"\n");
        }
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}
Example #7
0
int
main( int argc, char* argv[] )
{
    El::Environment env( argc, argv );

    try
    {
        const El::Int m = El::Input("--m","height of matrix",100);
        const El::Int n = El::Input("--n","width of matrix",200);
        const bool useIPM = El::Input("--useIPM","use Interior Point?",true);
        // TODO(poulson): Add options for controlling IPM
        const El::Int maxIter =
          El::Input("--maxIter","maximum # of iter's",500);
        const Real rho = El::Input("--rho","augmented Lagrangian param.",1.);
        const Real alpha = El::Input("--alpha","over-relaxation",1.2);
        const Real absTol = El::Input("--absTol","absolute tolerance",1e-6);
        const Real relTol = El::Input("--relTol","relative tolerance",1e-4);
        const Real pinvTol = El::Input("--pinvTol","pseudoinv tolerance",0.);
        const bool usePinv =
          El::Input("--usePinv","Directly compute pinv(A)",true);
        const bool progress = El::Input("--progress","print progress?",true);
        const bool display = El::Input("--display","display matrices?",false);
        const bool print = El::Input("--print","print matrices",false);
        El::ProcessInput();
        El::PrintInputReport();

        El::DistMatrix<Real> A, b, xTrue;
        El::Uniform( A, m, n );
        El::Uniform( b, m, 1 );
        if( print )
        {
            El::Print( A, "A" );
            El::Print( b, "b" );
        }
        if( display )
            El::Display( A, "A" );

        const bool sparse = false;
        El::BPCtrl<Real> ctrl(sparse);
        ctrl.useIPM = useIPM;
        ctrl.admmCtrl.rho = rho;
        ctrl.admmCtrl.alpha = alpha;
        ctrl.admmCtrl.maxIter = maxIter;
        ctrl.admmCtrl.absTol = absTol;
        ctrl.admmCtrl.relTol = relTol;
        ctrl.admmCtrl.usePinv = usePinv;
        ctrl.admmCtrl.pinvTol = pinvTol;
        ctrl.admmCtrl.progress = progress;
        ctrl.lpIPMCtrl.mehrotraCtrl.print = true;

        El::DistMatrix<Real> x;
        El::Timer timer;
        if( El::mpi::Rank() == 0 )
            timer.Start();
        El::BP( A, b, x, ctrl );
        if( El::mpi::Rank() == 0 )
            timer.Stop();
        if( print )
            El::Print( x, "x" );
        const El::Int xZeroNorm = El::ZeroNorm( x );
        if( El::mpi::Rank() == 0 )
        {
            El::Output("Basis Pursuit time: ",timer.Total()," secs");
            El::Output("|| x ||_0 = ",xZeroNorm);
        }
        SoftThreshold( x, El::Sqrt(El::limits::Epsilon<Real>()) );
        if( print )
            El::Print( x, "xThresh" );
        const El::Int xZeroNormThresh = El::ZeroNorm( x );
        if( El::mpi::Rank() == 0 )
        {
            El::Output("|| xThresh ||_0 = ",xZeroNormThresh);
        }
    }
    catch( std::exception& e ) { El::ReportException(e); }

    return 0;
}