IpMultiVectorMatrix.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2008 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 __IPMULTIVECTORMATRIX_HPP__
#define __IPMULTIVECTORMATRIX_HPP__
 
#include "IpUtils.hpp"
#include "IpMatrix.hpp"
 
namespace Ipopt
{
 
class MultiVectorMatrixSpace;
 
class IPOPTLIB_EXPORT MultiVectorMatrix: public Matrix
{
public:
 
   MultiVectorMatrix(
      const MultiVectorMatrixSpace* owner_space
   );
 
   ~MultiVectorMatrix();
 
   SmartPtr<MultiVectorMatrix> MakeNewMultiVectorMatrix() const;
 
   void SetVector(
      Index         i,
      const Vector& vec
   );
 
   /* For the non-const version, keep in mind that operations that
    * change this matrix also change the Vector that has been given
    * here.
    */
   void SetVectorNonConst(
      Index   i,
      Vector& vec
   );
 
   inline SmartPtr<const Vector> GetVector(
      Index i
   ) const
   {
      return ConstVec(i);
   }
 
   inline SmartPtr<Vector> GetVectorNonConst(
      Index i
   )
   {
      ObjectChanged();
      return Vec(i);
   }
 
   void ScaleRows(
      const Vector& scal_vec
   );
 
   void ScaleColumns(
      const Vector& scal_vec);
 
   void AddOneMultiVectorMatrix(
      Number                   a,
      const MultiVectorMatrix& mv1,
      Number                   c
   );
 
   void AddRightMultMatrix(
      Number                   a,
      const MultiVectorMatrix& U,
      const Matrix&            C,
      Number                   b
   );
 
   void FillWithNewVectors();
 
   void LRMultVector(
      Number        alpha,
      const Vector& x,
      Number        beta,
      Vector&       y
   ) const;
 
   SmartPtr<const VectorSpace> ColVectorSpace() const;
 
   SmartPtr<const MultiVectorMatrixSpace> MultiVectorMatrixOwnerSpace() 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:
 
   MultiVectorMatrix();
 
   MultiVectorMatrix(
      const MultiVectorMatrix&
   );
 
   void operator=(
      const MultiVectorMatrix&
   );
 
   const MultiVectorMatrixSpace* owner_space_;
 
   std::vector<SmartPtr<const Vector> > const_vecs_;
 
   std::vector<SmartPtr<Vector> > non_const_vecs_;
 
   inline const Vector* ConstVec(
      Index i
   ) const
   {
      DBG_ASSERT(i < NCols());
      DBG_ASSERT(IsValid(const_vecs_[i]) || IsValid(non_const_vecs_[i]));
      if( IsValid(non_const_vecs_[i]) )
      {
         return GetRawPtr(non_const_vecs_[i]);
      }
      else
      {
         return GetRawPtr(const_vecs_[i]);
      }
   }
 
   inline Vector* Vec(
      Index i
   )
   {
      DBG_ASSERT(i < NCols());
      DBG_ASSERT(IsValid(non_const_vecs_[i]));
      return GetRawPtr(non_const_vecs_[i]);
   }
};
 
class IPOPTLIB_EXPORT MultiVectorMatrixSpace: public MatrixSpace
{
public:
 
   MultiVectorMatrixSpace(
      Index              ncols,
      const VectorSpace& vec_space
   );
 
   ~MultiVectorMatrixSpace()
   { }
 
   MultiVectorMatrix* MakeNewMultiVectorMatrix() const
   {
      return new MultiVectorMatrix(this);
   }
 
   virtual Matrix* MakeNew() const
   {
      return MakeNewMultiVectorMatrix();
   }
 
   SmartPtr<const VectorSpace> ColVectorSpace() const
   {
      return vec_space_;
   }
 
private:
   SmartPtr<const VectorSpace> vec_space_;
 
};
 
inline MultiVectorMatrix::~MultiVectorMatrix()
{ }
 
inline SmartPtr<MultiVectorMatrix> MultiVectorMatrix::MakeNewMultiVectorMatrix() const
{
   return owner_space_->MakeNewMultiVectorMatrix();
}
 
inline SmartPtr<const VectorSpace> MultiVectorMatrix::ColVectorSpace() const
{
   return owner_space_->ColVectorSpace();
}
 
inline SmartPtr<const MultiVectorMatrixSpace> MultiVectorMatrix::MultiVectorMatrixOwnerSpace() const
{
   return owner_space_;
}
 
} // namespace Ipopt
#endif