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.
//
// $Id: IpMultiVectorMatrix.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors:  Andreas Waechter             IBM    2005-12-24
 
#ifndef __IPMULTIVECTORMATRIX_HPP__
#define __IPMULTIVECTORMATRIX_HPP__
 
#include "IpUtils.hpp"
#include "IpMatrix.hpp"
 
namespace Ipopt
{
 
  class MultiVectorMatrixSpace;
 
  class 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 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