IpCompoundSymMatrix.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 __IPCOMPOUNDSYMMATRIX_HPP__
#define __IPCOMPOUNDSYMMATRIX_HPP__
 
#include "IpUtils.hpp"
#include "IpSymMatrix.hpp"
 
namespace Ipopt
{
 
/* forward declarations */
class CompoundSymMatrixSpace;
 
class IPOPTLIB_EXPORT CompoundSymMatrix: public SymMatrix
{
public:
 
 
   CompoundSymMatrix(
      const CompoundSymMatrixSpace* owner_space
   );
 
   ~CompoundSymMatrix();
 
   void SetComp(
      Index         irow,
      Index         jcol,
      const Matrix& matrix
   );
 
   void SetCompNonConst(
      Index   irow,
      Index   jcol,
      Matrix& matrix
   );
 
   SmartPtr<const Matrix> GetComp(
      Index irow,
      Index jcol
   ) const
   {
      return ConstComp(irow, jcol);
   }
 
   SmartPtr<Matrix> GetCompNonConst(
      Index irow,
      Index jcol
   )
   {
      ObjectChanged();
      return Comp(irow, jcol);
   }
 
   SmartPtr<CompoundSymMatrix> MakeNewCompoundSymMatrix() const;
 
   // The following don't seem to be necessary
   /* Number of block rows of this compound matrix. */
   //    Index NComps_NRows() const { return NComps_Dim(); }
   /* Number of block colmuns of this compound matrix. */
   //    Index NComps_NCols() const { return NComps_Dim(); }
 
   Index NComps_Dim() const;
 
protected:
   virtual void MultVectorImpl(
      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 PrintImpl(
      const Journalist&  jnlst,
      EJournalLevel      level,
      EJournalCategory   category,
      const std::string& name,
      Index              indent,
      const std::string& prefix
   ) const;
 
private:
 
   CompoundSymMatrix();
 
   CompoundSymMatrix(
      const CompoundSymMatrix&
   );
 
   void operator=(
      const CompoundSymMatrix&
   );
 
   std::vector<std::vector<SmartPtr<Matrix> > > comps_;
 
   std::vector<std::vector<SmartPtr<const Matrix> > > const_comps_;
 
   const CompoundSymMatrixSpace* owner_space_;
 
   mutable bool matrices_valid_;
 
   bool MatricesValid() const;
 
   const Matrix* ConstComp(
      Index irow,
      Index jcol
   ) const
   {
      DBG_ASSERT(irow < NComps_Dim());
      DBG_ASSERT(jcol <= irow);
      if( IsValid(comps_[irow][jcol]) )
      {
         return GetRawPtr(comps_[irow][jcol]);
      }
      else if( IsValid(const_comps_[irow][jcol]) )
      {
         return GetRawPtr(const_comps_[irow][jcol]);
      }
 
      return NULL;
   }
 
   Matrix* Comp(
      Index irow,
      Index jcol
   )
   {
      DBG_ASSERT(irow < NComps_Dim());
      DBG_ASSERT(jcol <= irow);
      // We shouldn't be asking for a non-const if this entry holds a
      // const one...
      DBG_ASSERT(IsNull(const_comps_[irow][jcol]));
      if( IsValid(comps_[irow][jcol]) )
      {
         return GetRawPtr(comps_[irow][jcol]);
      }
 
      return NULL;
   }
};
 
class IPOPTLIB_EXPORT CompoundSymMatrixSpace: public SymMatrixSpace
{
public:
 
   CompoundSymMatrixSpace(
      Index ncomp_spaces,
      Index total_dim
   );
 
   ~CompoundSymMatrixSpace()
   { }
 
 
   void SetBlockDim(
      Index irow_jcol,
      Index dim
   );
 
   Index GetBlockDim(
      Index irow_jcol
   ) const;
 
   void SetCompSpace(
      Index              irow,
      Index              jcol,
      const MatrixSpace& mat_space,
      bool               auto_allocate = false
   );
 
   SmartPtr<const MatrixSpace> GetCompSpace(
      Index irow,
      Index jcol
   ) const
   {
      DBG_ASSERT(irow < ncomp_spaces_);
      DBG_ASSERT(jcol <= irow);
      return comp_spaces_[irow][jcol];
   }
 
   Index NComps_Dim() const
   {
      return ncomp_spaces_;
   }
 
   CompoundSymMatrix* MakeNewCompoundSymMatrix() const;
 
   virtual SymMatrix* MakeNewSymMatrix() const
   {
      return MakeNewCompoundSymMatrix();
   }
 
private:
 
   CompoundSymMatrixSpace();
 
   CompoundSymMatrixSpace(
      const CompoundSymMatrix&
   );
 
   CompoundSymMatrixSpace& operator=(
      const CompoundSymMatrixSpace&
   );
 
   Index ncomp_spaces_;
 
   std::vector<Index> block_dim_;
 
   std::vector<std::vector<SmartPtr<const MatrixSpace> > > comp_spaces_;
 
   std::vector<std::vector<bool> > allocate_block_;
 
   mutable bool dimensions_set_;
 
   bool DimensionsSet() const;
};
 
inline SmartPtr<CompoundSymMatrix> CompoundSymMatrix::MakeNewCompoundSymMatrix() const
{
   return owner_space_->MakeNewCompoundSymMatrix();
}
 
} // namespace Ipopt
#endif