IpCompoundMatrix.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpCompoundMatrix.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPCOMPOUNDMATRIX_HPP__
#define __IPCOMPOUNDMATRIX_HPP__

#include "IpUtils.hpp"
#include "IpMatrix.hpp"

namespace Ipopt
{

  /* forward declarations */
  class CompoundMatrixSpace;

  class CompoundMatrix : public Matrix
  {
  public:


    CompoundMatrix(const CompoundMatrixSpace* owner_space);

    ~CompoundMatrix();

    void SetComp(Index irow, Index jcol, const Matrix& matrix);

    void SetCompNonConst(Index irow, Index jcol, Matrix& matrix);

    void CreateBlockFromSpace(Index irow, Index jcol);

    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);
    }

    inline Index NComps_Rows() const;
    inline Index NComps_Cols() 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 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;

    virtual void PrintImpl(const Journalist& jnlst,
                           EJournalLevel level,
                           EJournalCategory category,
                           const std::string& name,
                           Index indent,
                           const std::string& prefix) const;

  private:
    CompoundMatrix();

    CompoundMatrix(const CompoundMatrix&);

    void operator=(const CompoundMatrix&);

    std::vector<std::vector<SmartPtr<Matrix> > > comps_;

    std::vector<std::vector<SmartPtr<const Matrix> > > const_comps_;

    const CompoundMatrixSpace* owner_space_;

    mutable bool matrices_valid_;

    bool MatricesValid() const;

    inline const Matrix* ConstComp(Index irow, Index jcol) const;

    inline Matrix* Comp(Index irow, Index jcol);
  };

  class CompoundMatrixSpace : public MatrixSpace
  {
  public:
    CompoundMatrixSpace(Index ncomps_rows,
                        Index ncomps_cols,
                        Index total_nRows,
                        Index total_nCols);

    ~CompoundMatrixSpace()
    {}
    ;

    void SetBlockRows(Index irow, Index nrows);

    void SetBlockCols(Index jcol, Index ncols);

    Index GetBlockRows(Index irow) const;

    Index GetBlockCols(Index 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<NComps_Rows());
      DBG_ASSERT(jcol<NComps_Cols());
      return comp_spaces_[irow][jcol];
    }

    Index NComps_Rows() const
    {
      return ncomps_rows_;
    }
    Index NComps_Cols() const
    {
      return ncomps_cols_;
    }

    bool Diagonal() const
    {
      return diagonal_;
    }

    CompoundMatrix* MakeNewCompoundMatrix() const;

    virtual Matrix* MakeNew() const
    {
      return MakeNewCompoundMatrix();
    }

  private:
    CompoundMatrixSpace();

    CompoundMatrixSpace(const CompoundMatrixSpace&);

    CompoundMatrixSpace& operator=(const CompoundMatrixSpace&);

    Index ncomps_rows_;

    Index ncomps_cols_;

    mutable bool dimensions_set_;

    std::vector<std::vector<SmartPtr<const MatrixSpace> > > comp_spaces_;

    std::vector<std::vector< bool > > allocate_block_;

    std::vector<Index> block_rows_;

    std::vector<Index> block_cols_;

    bool diagonal_;

    bool DimensionsSet() const;
  };

  /* inline methods */
  inline
  Index CompoundMatrix::NComps_Rows() const
  {
    return owner_space_->NComps_Rows();
  }

  inline
  Index CompoundMatrix::NComps_Cols() const
  {
    return owner_space_->NComps_Cols();
  }

  inline
  const Matrix* CompoundMatrix::ConstComp(Index irow, Index jcol) const
  {
    DBG_ASSERT(irow < NComps_Rows());
    DBG_ASSERT(jcol < NComps_Cols());
    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;
  }

  inline
  Matrix* CompoundMatrix::Comp(Index irow, Index jcol)
  {
    DBG_ASSERT(irow < NComps_Rows());
    DBG_ASSERT(jcol < NComps_Cols());
    return GetRawPtr(comps_[irow][jcol]);
  }

} // namespace Ipopt
#endif