/home/coin/SVN-release/CoinAll-1.1.0/Ipopt/src/LinAlg/IpDenseVector.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpDenseVector.hpp 920 2007-03-04 17:34:28Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPDENSEVECTOR_HPP__
#define __IPDENSEVECTOR_HPP__

#include "IpUtils.hpp"
#include "IpVector.hpp"

namespace Ipopt
{

  /* forward declarations */
  class DenseVectorSpace;

  class DenseVector : public Vector
  {
  public:

    DenseVector(const DenseVectorSpace* owner_space);

    virtual ~DenseVector();

    SmartPtr<DenseVector> MakeNewDenseVector() const;

    void SetValues(const Number *x);

    inline Number* Values();

    inline const Number* Values() const;

    const Number* ExpandedValues() const;

    inline Number* ExpandedValues()
    {
      return Values();
    }

    bool IsHomogeneous() const
    {
      return homogeneous_;
    }

    Number Scalar() const
    {
      DBG_ASSERT(homogeneous_);
      return scalar_;
    }

    void CopyToPos(Index Pos, const Vector& x);
    void CopyFromPos(Index Pos, Vector& x) const;

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

    /* 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:
    DenseVector();

    DenseVector(const DenseVector&);

    void operator=(const DenseVector&);

    const DenseVectorSpace* owner_space_;

    Number* values_;

    mutable Number* expanded_values_;

    Number* values_allocated();

    bool initialized_;

    bool homogeneous_;

    Number scalar_;

    void set_values_from_scalar();
  };

  class DenseVectorSpace : public VectorSpace
  {
  public:
    DenseVectorSpace(Index dim)
        :
        VectorSpace(dim)
    {}

    ~DenseVectorSpace()
    {}

    DenseVector* MakeNewDenseVector() const
    {
      return new DenseVector(this);
    }

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

    Number* AllocateInternalStorage() const;

    void FreeInternalStorage(Number* values) const;
  };

  // inline functions
  inline Number* DenseVector::Values()
  {
    // Here we assume that every time someone requests this direct raw
    // pointer, the data is going to change and the Tag for this
    // vector has to be updated.

    if (initialized_ && homogeneous_) {
      // If currently the vector is a homogeneous vector, set all elements
      // explicitly to this value
      set_values_from_scalar();
    }
    ObjectChanged();
    initialized_= true;
    homogeneous_ = false;
    return values_allocated();
  }

  inline const Number* DenseVector::Values() const
  {
    DBG_ASSERT(initialized_ && (Dim()==0 || values_));
    return values_;
  }

  inline Number* DenseVector::values_allocated()
  {
    if (values_==NULL) {
      values_ = owner_space_->AllocateInternalStorage();
    }
    return values_;
  }

  inline
  Number* DenseVectorSpace::AllocateInternalStorage() const
  {
    if (Dim()>0) {
      return new Number[Dim()];
    }
    else {
      return NULL;
    }
  }

  inline
  void DenseVectorSpace::FreeInternalStorage(Number* values) const
  {
    delete [] values;
  }

  inline
  SmartPtr<DenseVector> DenseVector::MakeNewDenseVector() const
  {
    return owner_space_->MakeNewDenseVector();
  }

} // namespace Ipopt
#endif

---