IpMatrix.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: IpMatrix.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPMATRIX_HPP__
#define __IPMATRIX_HPP__

#include "IpVector.hpp"

namespace Ipopt
{

  /* forward declarations */
  class MatrixSpace;

  class Matrix : public TaggedObject
  {
  public:
    Matrix(const MatrixSpace* owner_space);

    virtual ~Matrix();

    void MultVector(Number alpha, const Vector& x, Number beta,
                    Vector& y) const;

    void TransMultVector(Number alpha, const Vector& x, Number beta,
                         Vector& y) const;

    void AddMSinvZ(Number alpha, const Vector& S, const Vector& Z,
                   Vector& X) const;

    void SinvBlrmZMTdBr(Number alpha, const Vector& S,
                        const Vector& R, const Vector& Z,
                        const Vector& D, Vector& X) const;

    bool HasValidNumbers() const;

    //* @name Information about the size of the matrix */

    Index  NRows() const;

    Index  NCols() const;

    virtual void Print(SmartPtr<const Journalist> jnlst,
                       EJournalLevel level,
                       EJournalCategory category,
                       const std::string& name,
                       Index indent=0,
                       const std::string& prefix="") const;
    virtual void Print(const Journalist& jnlst,
                       EJournalLevel level,
                       EJournalCategory category,
                       const std::string& name,
                       Index indent=0,
                       const std::string& prefix="") const;

    SmartPtr<const MatrixSpace> OwnerSpace() const;

  protected:
    virtual void MultVectorImpl(Number alpha, const Vector& x, Number beta, Vector& y) const =0;

    virtual void TransMultVectorImpl(Number alpha, const Vector& x, Number beta, Vector& y) const =0;

    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
    {
      return true;
    }

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

  private:
    Matrix();

    Matrix(const Matrix&);

    Matrix& operator=(const Matrix&);

    const SmartPtr<const MatrixSpace> owner_space_;

    mutable TaggedObject::Tag valid_cache_tag_;
    mutable bool cached_valid_;
  };


  class MatrixSpace : public ReferencedObject
  {
  public:
    MatrixSpace(Index nRows, Index nCols);

    virtual ~MatrixSpace();

    virtual Matrix* MakeNew() const=0;

    Index NRows() const
    {
      return nRows_;
    }
    Index NCols() const
    {
      return nCols_;
    }

    bool IsMatrixFromSpace(const Matrix& matrix) const;

  private:
    MatrixSpace();

    MatrixSpace(const MatrixSpace&);

    MatrixSpace& operator=(const MatrixSpace&);

    const Index nRows_;
    const Index nCols_;
  };


  /* Inline Methods */
  inline
  Matrix::Matrix(const MatrixSpace* owner_space)
      :
      TaggedObject(),
      owner_space_(owner_space),
      valid_cache_tag_(0)
  {}

  inline
  Matrix::~Matrix()
  {}

  inline
  Index  Matrix::NRows() const
  {
    return owner_space_->NRows();
  }

  inline
  Index  Matrix::NCols() const
  {
    return owner_space_->NCols();
  }

  inline
  SmartPtr<const MatrixSpace> Matrix::OwnerSpace() const
  {
    return owner_space_;
  }

} // namespace Ipopt

// Macro definitions for debugging matrices
#ifndef IP_DEBUG
# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat)
#else
# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) \
   if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \
      if (dbg_jrnl.Jnlst()!=NULL) { \
        (__mat).Print(dbg_jrnl.Jnlst(), \
              J_ERROR, J_DBG, \
              __mat_name, \
              dbg_jrnl.IndentationLevel()*2, \
              "# "); \
      } \
   }
#endif // IP_DEBUG

#endif