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