IpTripletToDenseConverter.hpp

Go to the documentation of this file.

#ifndef __IPTRIPLETTODENSECONVERTER_HPP__
#define __IPTRIPLETTODENSECONVERTER_HPP__

#include "IpUtils.hpp"
#include "IpReferenced.hpp"
namespace Ipopt
{

  class TripletToDenseConverter: public ReferencedObject
  {
    class TripletEntry
    {
    public:
      TripletEntry()
      {}

      ~TripletEntry()
      {}

      TripletEntry(const TripletEntry&)
      {}

      void Set(Index i_row, Index j_col, Index i_pos_triplet)
      {
        if (i_row>j_col) {
          i_row_ = j_col;
          j_col_ = i_row;
        }
        else {
          i_row_ = i_row;
          j_col_ = j_col;
        }
        i_pos_triplet_ = i_pos_triplet;
      }

      Index IRow() const
      {
        return i_row_;
      }
      Index JCol() const
      {
        return j_col_;
      }
      Index PosTriplet() const
      {
        return i_pos_triplet_;
      }

      bool operator< (const TripletEntry& Tentry) const
      {
        return ((i_row_ < Tentry.i_row_) ||
                (i_row_==Tentry.i_row_ && j_col_<Tentry.j_col_));
      }

    private:
      //TripletEntry();

      /*
      TripletEntry(const TripletEntry&);
      */

      void operator=(const TripletEntry&);

      Index i_row_;
      Index j_col_;
      Index i_pos_triplet_;
    };

  public:
    /* Constructor.  If offset is 0, then the counting of indices in
       the compressed format starts a 0 (C-style numbering); if offset
       is 1, then the counting starts at 1 (Fortran-type
       numbering). */
    TripletToDenseConverter(Index offset);

    virtual ~TripletToDenseConverter();

    Index InitializeConverter(Index dim, Index nonzeros,
                              const Index* airn,
                              const Index* ajcn);

    const Index* IA() const
    {
      DBG_ASSERT(initialized_);
      return ia_;
    }

    const Index* JA() const
    {
      DBG_ASSERT(initialized_);
      return ja_;
    }

    void ConvertValues(Index nonzeros_triplet, const Number* a_triplet,
                       Index nonzeros_compressed, Number* a_compressed);

  private:
    TripletToDenseConverter();

    TripletToDenseConverter(const TripletToDenseConverter&);

    void operator=(const TripletToDenseConverter&);

    Index offset_;

    Index* ia_;

    Index* ja_;

    Index dim_;

    Index nonzeros_triplet_;

    Index nonzeros_compressed_;

    bool initialized_;

    Index* ipos_first_;
    Index* ipos_double_triplet_;
    Index* ipos_double_compressed_;
  };


} // namespace Ipopt

#endif