sparseqr/driver.hh

Go to the documentation of this file.

/* driver class for the sparseqr factorization
 */

#ifndef sparseqrDriver_hh
#define sparseqrDriver_hh

#include <memory>
#include "basics/typedefs.hh"
#include "operator/compositions.hh"
#include "operator/sparseMatrix.hh"
#include "operator/permutation.hh"
#include "sparseqr/sparseqr.hh"
#include "sparseqr/givensRotations.hh"

using concepts::Real;

namespace sparseqr {

  // **************************************************************** Driver **

  class Driver : concepts::Operator<Real> {
  public:
    Driver(const concepts::SparseMatrix<Real>& A)
      : concepts::Operator<Real>(A.dimY(), A.dimX()) 
      , rank_(0), A_(A), computed_(false)
      , Prow_(0), Pcol_(0), Q_(0), Qt_(0), restr_(0), ext_(0)
      , prow_(0), pcol_(0), qr_(0) {}
    virtual ~Driver();
    concepts::Permutation<Real>* Prow();
    concepts::Permutation<Real>* Pcol();
    sparseqr::GivensRotations<Real>* Q();
    sparseqr::GivensRotations<Real>* Qt();
    concepts::TrivExtendRestrict<Real>* restriction();
    concepts::TrivExtendRestrict<Real>* extension();
    inline int rank();

    virtual void operator()(const concepts::Function<Real>& fncY,
                            concepts::Function<Real>& fncX);
    void operator()(const concepts::Vector<Real>& fncY,
                    concepts::Vector<Real>& fncX);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    void compute_();
    int rank_;
    const concepts::SparseMatrix<Real>& A_;
    bool computed_;
    std::auto_ptr<concepts::Permutation<Real> > Prow_, Pcol_;
    std::auto_ptr<sparseqr::GivensRotations<Real> > Q_, Qt_;
    std::auto_ptr<concepts::TrivExtendRestrict<Real> > restr_, ext_;
    concepts::Array<int> prow_, pcol_;
    std::auto_ptr<QR> qr_;
    sparseqr::Qmatrix q_;
  };

  int Driver::rank() {
    if (!computed_) compute_();
    return rank_;
  }

} // namespace sparseqr

#endif // sparseqrDriver_hh