IpTripletToCSRConverter.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2005-03-13
 
#ifndef __IPTRIPLETTOCSRCONVERTER_HPP__
#define __IPTRIPLETTOCSRCONVERTER_HPP__
 
#include "IpUtils.hpp"
#include "IpReferenced.hpp"
namespace Ipopt
{
 
class TripletToCSRConverter: public ReferencedObject
{
   class TripletEntry
   {
   public:
 
      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:
      Index i_row_;
      Index j_col_;
      Index i_pos_triplet_;
   };
 
public:
   enum ETriFull
   {
      Triangular_Format,
      Full_Format
   };
 
   /* 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).
    */
   TripletToCSRConverter(
      Index    offset,
      ETriFull hf = Triangular_Format
   );
 
   virtual ~TripletToCSRConverter();
 
   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_;
   }
 
   const Index* iPosFirst() const
   {
      DBG_ASSERT(initialized_);
      return ipos_first_;
   }
 
   void ConvertValues(
      Index         nonzeros_triplet,
      const Number* a_triplet,
      Index         nonzeros_compressed,
      Number*       a_compressed
   );
 
private:
 
   TripletToCSRConverter();
 
   TripletToCSRConverter(
      const TripletToCSRConverter&
   );
 
   void operator=(
      const TripletToCSRConverter&
   );
 
   Index offset_;
 
   ETriFull hf_;
 
   Index* ia_;
 
   Index* ja_;
 
   Index dim_;
 
   Index nonzeros_triplet_;
 
   Index nonzeros_compressed_;
 
   Index num_doubles_;
 
   bool initialized_;
 
 
   Index* ipos_first_;
 
   Index* ipos_double_triplet_;
 
   Index* ipos_double_compressed_;
};
 
} // namespace Ipopt
 
#endif