IpDenseGenMatrix.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2009 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter             IBM    2005-12-24
 
#ifndef __IPDENSEGENMATRIX_HPP__
#define __IPDENSEGENMATRIX_HPP__
 
#include "IpUtils.hpp"
#include "IpMatrix.hpp"
#include "IpDenseVector.hpp"
#include "IpDenseSymMatrix.hpp"
 
namespace Ipopt
{
 
class DenseGenMatrixSpace;
 
class IPOPTLIB_EXPORT DenseGenMatrix: public Matrix
{
public:
 
 
   DenseGenMatrix(
      const DenseGenMatrixSpace* owner_space
   );
 
   ~DenseGenMatrix();
 
   SmartPtr<DenseGenMatrix> MakeNewDenseGenMatrix() const;
 
   Number* Values()
   {
      initialized_ = true;
      ObjectChanged();
      return values_;
   }
 
   const Number* Values() const
   {
      DBG_ASSERT(initialized_);
      return values_;
   }
 
   void Copy(
      const DenseGenMatrix& M
   );
 
   void FillIdentity(
      Number factor = 1.
   );
 
   void ScaleColumns(
      const DenseVector& scal_vec
   );
 
   void AddMatrixProduct(
      Number                alpha,
      const DenseGenMatrix& A,
      bool                  transA,
      const DenseGenMatrix& B,
      bool                  transB,
      Number                beta
   );
 
   void HighRankUpdateTranspose(
      Number                   alpha,
      const MultiVectorMatrix& V1,
      const MultiVectorMatrix& V2,
      Number                   beta
   );
 
   bool ComputeCholeskyFactor(
      const DenseSymMatrix& M
   );
 
   bool ComputeEigenVectors(
      const DenseSymMatrix& M,
      DenseVector&          Evalues
   );
 
   void CholeskyBackSolveMatrix(
      bool            trans,
      Number          alpha,
      DenseGenMatrix& B
   ) const;
 
   void CholeskySolveVector(
      DenseVector& b
   ) const;
 
   void CholeskySolveMatrix(
      DenseGenMatrix& B
   ) const;
 
   bool ComputeLUFactorInPlace();
 
   void LUSolveMatrix(
      DenseGenMatrix& B
   ) const;
 
   void LUSolveVector(
      DenseVector& b
   ) const;
 
protected:
   virtual void MultVectorImpl(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const;
 
   virtual void TransMultVectorImpl(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const;
 
   virtual bool HasValidNumbersImpl() const;
 
   virtual void ComputeRowAMaxImpl(
      Vector& rows_norms,
      bool    init
   ) const;
 
   virtual void ComputeColAMaxImpl(
      Vector& cols_norms,
      bool    init
   ) const;
 
   virtual void PrintImpl(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix
   ) const;
 
private:
 
   DenseGenMatrix();
 
   DenseGenMatrix(
      const DenseGenMatrix&
   );
 
   void operator=(
      const DenseGenMatrix&
   );
 
   const DenseGenMatrixSpace* owner_space_;
 
   Number* values_;
 
   bool initialized_;
 
   enum Factorization
   {
      NONE,
      LU,
      CHOL
   };
 
   Factorization factorization_;
 
   Index* pivot_;
};
 
class IPOPTLIB_EXPORT DenseGenMatrixSpace: public MatrixSpace
{
public:
 
   DenseGenMatrixSpace(
      Index nRows,
      Index nCols
   );
 
   ~DenseGenMatrixSpace()
   { }
 
   DenseGenMatrix* MakeNewDenseGenMatrix() const
   {
      return new DenseGenMatrix(this);
   }
 
   virtual Matrix* MakeNew() const
   {
      return MakeNewDenseGenMatrix();
   }
 
};
 
inline SmartPtr<DenseGenMatrix> DenseGenMatrix::MakeNewDenseGenMatrix() const
{
   return owner_space_->MakeNewDenseGenMatrix();
}
 
} // namespace Ipopt
#endif