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 2269 2013-05-05 11:32:40Z stefan $
//
// 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