IpMatrix.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPMATRIX_HPP__
#define __IPMATRIX_HPP__
 
#include "IpVector.hpp"
 
namespace Ipopt
{
 
/* forward declarations */
class MatrixSpace;
 
class IPOPTLIB_EXPORT Matrix: public TaggedObject
{
public:
 
   Matrix(
      const MatrixSpace* owner_space
   )
      : TaggedObject(),
        owner_space_(owner_space),
        valid_cache_tag_(0)
   { }
 
   virtual ~Matrix()
   { }
 
 
   void MultVector(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const
   {
      MultVectorImpl(alpha, x, beta, y);
   }
 
   void TransMultVector(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const
   {
      TransMultVectorImpl(alpha, x, beta, y);
   }
 
 
   void AddMSinvZ(
      Number        alpha,
      const Vector& S,
      const Vector& Z,
      Vector&       X
   ) const;
 
   void SinvBlrmZMTdBr(
      Number        alpha,
      const Vector& S,
      const Vector& R,
      const Vector& Z,
      const Vector& D,
      Vector&       X
   ) const;
 
   bool HasValidNumbers() const;
 
 
   inline Index NRows() const;
 
   inline Index NCols() const;
 
 
   void ComputeRowAMax(
      Vector& rows_norms,
      bool    init = true
   ) const
   {
      DBG_ASSERT(NRows() == rows_norms.Dim());
      if( init )
      {
         rows_norms.Set(0.);
      }
      ComputeRowAMaxImpl(rows_norms, init);
   }
 
   void ComputeColAMax(
      Vector& cols_norms,
      bool    init = true
   ) const
   {
      DBG_ASSERT(NCols() == cols_norms.Dim());
      if( init )
      {
         cols_norms.Set(0.);
      }
      ComputeColAMaxImpl(cols_norms, init);
   }
 
   virtual void Print(
      SmartPtr<const Journalist> jnlst,
      EJournalLevel              level,
      EJournalCategory           category,
      const std::string&         name,
      Index                      indent = 0,
      const std::string&         prefix = ""
   ) const;
 
   virtual void Print(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent = 0,
      const std::string& prefix = ""
   ) const;
 
   inline SmartPtr<const MatrixSpace> OwnerSpace() const;
 
protected:
 
   virtual void MultVectorImpl(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const = 0;
 
   virtual void TransMultVectorImpl(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const = 0;
 
   virtual void AddMSinvZImpl(
      Number        alpha,
      const Vector& S,
      const Vector& Z,
      Vector&       X
   ) const;
 
   virtual void SinvBlrmZMTdBrImpl(
      Number        alpha,
      const Vector& S,
      const Vector& R,
      const Vector& Z,
      const Vector& D,
      Vector&       X
   ) const;
 
   virtual bool HasValidNumbersImpl() const
   {
      return true;
   }
 
   virtual void ComputeRowAMaxImpl(
      Vector& rows_norms,
      bool    init
   ) const = 0;
 
   virtual void ComputeColAMaxImpl(
      Vector& cols_norms,
      bool    init
   ) const = 0;
 
   virtual void PrintImpl(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix
   ) const = 0;
 
private:
 
   Matrix();
 
   Matrix(
      const Matrix&
   );
 
   Matrix& operator=(
      const Matrix&
   );
 
   const SmartPtr<const MatrixSpace> owner_space_;
 
   mutable TaggedObject::Tag valid_cache_tag_;
   mutable bool cached_valid_;
};
 
class IPOPTLIB_EXPORT MatrixSpace: public ReferencedObject
{
public:
 
   MatrixSpace(
      Index nRows,
      Index nCols)
      : nRows_(nRows),
        nCols_(nCols)
   { }
 
   virtual ~MatrixSpace()
   { }
 
   virtual Matrix* MakeNew() const = 0;
 
   Index NRows() const
   {
      return nRows_;
   }
 
   Index NCols() const
   {
      return nCols_;
   }
 
   bool IsMatrixFromSpace(
      const Matrix& matrix
   ) const
   {
      return (matrix.OwnerSpace() == this);
   }
 
private:
 
   MatrixSpace();
 
   MatrixSpace(
      const MatrixSpace&
   );
 
   MatrixSpace& operator=(
      const MatrixSpace&
   );
 
   const Index nRows_;
 
   const Index nCols_;
};
 
/* Inline Methods */
inline Index Matrix::NRows() const
{
   return owner_space_->NRows();
}
 
inline Index Matrix::NCols() const
{
   return owner_space_->NCols();
}
 
inline SmartPtr<const MatrixSpace> Matrix::OwnerSpace() const
{
   return owner_space_;
}
 
} // namespace Ipopt
 
// Macro definitions for debugging matrices
#if IPOPT_VERBOSITY == 0
# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat)
#else
# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) \
   if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \
      if (dbg_jrnl.Jnlst()!=NULL) { \
        (__mat).Print(dbg_jrnl.Jnlst(), \
        J_ERROR, J_DBG, \
        __mat_name, \
        dbg_jrnl.IndentationLevel()*2, \
        "# "); \
      } \
   }
#endif // #if IPOPT_VERBOSITY == 0
 
#endif