Epetra_SerialDenseSolver.h

Go to the documentation of this file.

/*
//@HEADER
// ************************************************************************
//
//               Epetra: Linear Algebra Services Package
//                 Copyright 2011 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
//@HEADER
*/
 
#ifndef EPETRA_SERIALDENSESOLVER_H
#define EPETRA_SERIALDENSESOLVER_H
class Epetra_SerialDenseMatrix;
#include "Epetra_Object.h"
#include "Epetra_CompObject.h"
#include "Epetra_BLAS.h"
#include "Epetra_LAPACK.h"
 


 
//=========================================================================
class EPETRA_LIB_DLL_EXPORT Epetra_SerialDenseSolver :
  public Epetra_CompObject, public Epetra_BLAS,
  public Epetra_LAPACK, public Epetra_Object    {
  public:



  Epetra_SerialDenseSolver();
 

  virtual ~Epetra_SerialDenseSolver();



  int SetMatrix(Epetra_SerialDenseMatrix & A);


  int SetVectors(Epetra_SerialDenseMatrix & X, Epetra_SerialDenseMatrix & B);




  void FactorWithEquilibration(bool Flag) {Equilibrate_ = Flag; return;};

  void SolveWithTranspose(bool Flag) {Transpose_ = Flag; if (Flag) TRANS_ = 'T'; else TRANS_ = 'N'; return;};

  void SolveToRefinedSolution(bool Flag) {RefineSolution_ = Flag; return;};


  void EstimateSolutionErrors(bool Flag) ;




  virtual int Factor(void);


  virtual int Solve(void);


  virtual int Invert(void);


  virtual int ComputeEquilibrateScaling(void);


  virtual int EquilibrateMatrix(void);


  int EquilibrateRHS(void);
 


  virtual int ApplyRefinement(void);


  int UnequilibrateLHS(void);


  virtual int ReciprocalConditionEstimate(double & Value);



  bool Transpose() {return(Transpose_);};

  bool Factored() {return(Factored_);};

  bool A_Equilibrated() {return(A_Equilibrated_);};

  bool B_Equilibrated() {return(B_Equilibrated_);};

  virtual bool ShouldEquilibrate() {ComputeEquilibrateScaling(); return(ShouldEquilibrate_);};

  bool SolutionErrorsEstimated() {return(SolutionErrorsEstimated_);};

  bool Inverted() {return(Inverted_);};

  bool ReciprocalConditionEstimated() {return(ReciprocalConditionEstimated_);};

  bool Solved() {return(Solved_);};

  bool SolutionRefined() {return(SolutionRefined_);};



   Epetra_SerialDenseMatrix * Matrix()  const {return(Matrix_);};

   Epetra_SerialDenseMatrix * FactoredMatrix()  const {return(Factor_);};

  Epetra_SerialDenseMatrix * LHS()  const {return(LHS_);};

  Epetra_SerialDenseMatrix * RHS()  const {return(RHS_);};

  int M()  const {return(M_);};

  int N()  const {return(N_);};

  double * A()  const {return(A_);};

  int LDA()  const {return(LDA_);};

  double * B()  const {return(B_);};

  int LDB()  const {return(LDB_);};

  int NRHS()  const {return(NRHS_);};

  double * X()  const {return(X_);};

  int LDX()  const {return(LDX_);};

  double * AF()  const {return(AF_);};

  int LDAF()  const {return(LDAF_);};

  int * IPIV()  const {return(IPIV_);};

  double ANORM()  const {return(ANORM_);};

  double RCOND()  const {return(RCOND_);};


  double ROWCND()  const {return(ROWCND_);};


  double COLCND()  const {return(COLCND_);};

  double AMAX()  const {return(AMAX_);};

  double * FERR()  const {return(FERR_);};

  double * BERR()  const {return(BERR_);};

  double * R()  const {return(R_);};

  double * C()  const {return(C_);};



  virtual void Print(std::ostream& os) const;
 protected:
 
  void AllocateWORK() {if (WORK_==0) {LWORK_ = 4*N_; WORK_ = new double[LWORK_];} return;};
  void AllocateIWORK() {if (IWORK_==0) IWORK_ = new int[N_]; return;};
  void InitPointers();
  void DeleteArrays();
  void ResetMatrix();
  void ResetVectors();
 
 
  bool Equilibrate_;
  bool ShouldEquilibrate_;
  bool A_Equilibrated_;
  bool B_Equilibrated_;
  bool Transpose_;
  bool Factored_;
  bool EstimateSolutionErrors_;
  bool SolutionErrorsEstimated_;
  bool Solved_;
  bool Inverted_;
  bool ReciprocalConditionEstimated_;
  bool RefineSolution_;
  bool SolutionRefined_;
 
  char TRANS_;
 
  int M_;
  int N_;
  int Min_MN_;
  int NRHS_;
  int LDA_;
  int LDAF_;
  int LDB_;
  int LDX_;
  int INFO_;
  int LWORK_;
 
  int * IPIV_;
  int * IWORK_;
 
  double ANORM_;
  double RCOND_;
  double ROWCND_;
  double COLCND_;
  double AMAX_;
 
  Epetra_SerialDenseMatrix * Matrix_;
  Epetra_SerialDenseMatrix * LHS_;
  Epetra_SerialDenseMatrix * RHS_;
  Epetra_SerialDenseMatrix * Factor_;
 
  double * A_;
  double * FERR_;
  double * BERR_;
  double * AF_;
  double * WORK_;
  double * R_;
  double * C_;
 
  double * B_;
  double * X_;
 
 
 private:
  // Epetra_SerialDenseSolver copy constructor (put here because we don't want user access)
 
  Epetra_SerialDenseSolver(const Epetra_SerialDenseSolver& Source);
  Epetra_SerialDenseSolver & operator=(const Epetra_SerialDenseSolver& Source);
};
 
#endif /* EPETRA_SERIALDENSESOLVER_H */