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

#ifndef __IPCOMPOUNDVECTOR_HPP__
#define __IPCOMPOUNDVECTOR_HPP__

#include "IpUtils.hpp"
#include "IpVector.hpp"
#include <vector>

namespace Ipopt
{

  /* forward declarations */
  class CompoundVectorSpace;

  class CompoundVector : public Vector
  {
  public:
    CompoundVector(const CompoundVectorSpace* owner_space, bool create_new);

    virtual ~CompoundVector();

    void SetComp(Index icomp, const Vector& vec);

    void SetCompNonConst(Index icomp, Vector& vec);

    inline Index NComps() const;

    bool IsCompConst(Index i) const
    {
      DBG_ASSERT(i > 0 && i < NComps());
      DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i]));
      if (IsValid(const_comps_[i])) {
        return true;
      }
      return false;
    }

    bool IsCompNull(Index i) const
    {
      DBG_ASSERT(i >= 0 && i < NComps());
      if (IsValid(comps_[i]) || IsValid(const_comps_[i])) {
        return false;
      }
      return true;
    }

    SmartPtr<const Vector> GetComp(Index i) const
    {
      return ConstComp(i);
    }

    SmartPtr<Vector> GetCompNonConst(Index i)
    {
      ObjectChanged();
      return Comp(i);
    }

  protected:
    virtual void CopyImpl(const Vector& x);

    virtual void ScalImpl(Number alpha);

    virtual void AxpyImpl(Number alpha, const Vector &x);

    virtual Number DotImpl(const Vector &x) const;

    virtual Number Nrm2Impl() const;

    virtual Number AsumImpl() const;

    virtual Number AmaxImpl() const;

    virtual void SetImpl(Number value);

    virtual void ElementWiseDivideImpl(const Vector& x);

    virtual void ElementWiseMultiplyImpl(const Vector& x);

    virtual void ElementWiseMaxImpl(const Vector& x);

    virtual void ElementWiseMinImpl(const Vector& x);

    virtual void ElementWiseReciprocalImpl();

    virtual void ElementWiseAbsImpl();

    virtual void ElementWiseSqrtImpl();

    virtual void ElementWiseSgnImpl();

    virtual void AddScalarImpl(Number scalar);

    virtual Number MaxImpl() const;

    virtual Number MinImpl() const;

    virtual Number SumImpl() const;

    virtual Number SumLogsImpl() const;

    void AddTwoVectorsImpl(Number a, const Vector& v1,
                           Number b, const Vector& v2, Number c);
    Number FracToBoundImpl(const Vector& delta, Number tau) const;
    void AddVectorQuotientImpl(Number a, const Vector& z, const Vector& s,
                               Number c);

    virtual bool HasValidNumbersImpl() const;

    /* Print the entire vector with padding */
    virtual void PrintImpl(const Journalist& jnlst,
                           EJournalLevel level,
                           EJournalCategory category,
                           const std::string& name,
                           Index indent,
                           const std::string& prefix) const;

  private:
    CompoundVector();

    CompoundVector(const CompoundVector&);

    void operator=(const CompoundVector&);

    std::vector< SmartPtr<Vector> > comps_;
    std::vector< SmartPtr<const Vector> > const_comps_;

    const CompoundVectorSpace* owner_space_;

    bool vectors_valid_;

    bool VectorsValid();

    inline const Vector* ConstComp(Index i) const;

    inline Vector* Comp(Index i);
  };

  class CompoundVectorSpace : public VectorSpace
  {
  public:
    CompoundVectorSpace(Index ncomp_spaces, Index total_dim);

    ~CompoundVectorSpace()
    {}

    virtual void SetCompSpace(Index icomp                   ,
                              const VectorSpace& vec_space 
                             );

    SmartPtr<const VectorSpace> GetCompSpace(Index icomp) const;

    Index NCompSpaces() const
    {
      return ncomp_spaces_;
    }

    virtual CompoundVector* MakeNewCompoundVector(bool create_new = true) const
    {
      return new CompoundVector(this, create_new);
    }

    virtual Vector* MakeNew() const
    {
      return MakeNewCompoundVector();
    }

  private:
    CompoundVectorSpace();

    CompoundVectorSpace(const CompoundVectorSpace&);

    CompoundVectorSpace& operator=(const CompoundVectorSpace&);

    const Index ncomp_spaces_;

    std::vector< SmartPtr<const VectorSpace> > comp_spaces_;
  };

  /* inline methods */
  inline
  Index CompoundVector::NComps() const
  {
    return owner_space_->NCompSpaces();
  }

  inline
  const Vector* CompoundVector::ConstComp(Index i) const
  {
    DBG_ASSERT(i < NComps());
    DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i]));
    if (IsValid(comps_[i])) {
      return GetRawPtr(comps_[i]);
    }
    else if (IsValid(const_comps_[i])) {
      return GetRawPtr(const_comps_[i]);
    }

    DBG_ASSERT(false && "shouldn't be here");
    return NULL;
  }

  inline
  Vector* CompoundVector::Comp(Index i)
  {
    DBG_ASSERT(i < NComps());
    DBG_ASSERT(IsValid(comps_[i]));
    return GetRawPtr(comps_[i]);
  }

} // namespace Ipopt

#endif