Epetra_CrsGraph.h

Go to the documentation of this file.

/*
//@HEADER
// ************************************************************************
//
//               Epetra: Linear Algebra Services Package
//                 Copyright 2011 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

#ifndef EPETRA_CRSGRAPH_H
#define EPETRA_CRSGRAPH_H

#include "Epetra_ConfigDefs.h"
#include "Epetra_DistObject.h"
#include "Epetra_CrsGraphData.h"
class Epetra_BlockMap;
class Epetra_Util;
class Epetra_Time;
class Epetra_Import;
class Epetra_Export;
class Epetra_Distributor;
class Epetra_RowMatrix;


class EPETRA_LIB_DLL_EXPORT Epetra_CrsGraph: public Epetra_DistObject {

 public:



  Epetra_CrsGraph(Epetra_DataAccess CV, const Epetra_BlockMap& RowMap, const int* NumIndicesPerRow, bool StaticProfile = false);


  Epetra_CrsGraph(Epetra_DataAccess CV, const Epetra_BlockMap& RowMap, int NumIndicesPerRow, bool StaticProfile = false);


  Epetra_CrsGraph(Epetra_DataAccess CV, const Epetra_BlockMap& RowMap,
      const Epetra_BlockMap& ColMap, const int* NumIndicesPerRow, bool StaticProfile = false);


  Epetra_CrsGraph(Epetra_DataAccess CV, const Epetra_BlockMap& RowMap,
      const Epetra_BlockMap& ColMap, int NumIndicesPerRow, bool StaticProfile = false);


  Epetra_CrsGraph(const Epetra_CrsGraph& Graph);

  virtual ~Epetra_CrsGraph();



#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int InsertGlobalIndices(int GlobalRow, int NumIndices, int* Indices);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int InsertGlobalIndices(long long GlobalRow, int NumIndices, long long* Indices);
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int RemoveGlobalIndices(int GlobalRow, int NumIndices, int* Indices);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int RemoveGlobalIndices(long long GlobalRow, int NumIndices, long long* Indices);
#endif


  int RemoveGlobalIndices(long long Row);



  int InsertMyIndices(int LocalRow, int NumIndices, int* Indices);


  int RemoveMyIndices(int LocalRow, int NumIndices, int* Indices);


  int RemoveMyIndices(int Row);




  int FillComplete();


  int FillComplete(const Epetra_BlockMap& DomainMap, const Epetra_BlockMap& RangeMap);


  int OptimizeStorage();





#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int ExtractGlobalRowCopy(int GlobalRow, int LenOfIndices, int& NumIndices, int* Indices) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int ExtractGlobalRowCopy(long long GlobalRow, int LenOfIndices, int& NumIndices, long long* Indices) const;
#endif


  int ExtractMyRowCopy(int LocalRow, int LenOfIndices, int& NumIndices, int* Indices) const;


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int ExtractGlobalRowView(int GlobalRow, int& NumIndices, int*& Indices) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int ExtractGlobalRowView(long long GlobalRow, int& NumIndices, long long*& Indices) const;
#endif


  int ExtractMyRowView(int LocalRow, int& NumIndices, int*& Indices) const;


  bool Filled() const {return(CrsGraphData_->Filled_);}

  bool StorageOptimized() const {return(CrsGraphData_->StorageOptimized_);}

  bool IndicesAreGlobal() const {return(CrsGraphData_->IndicesAreGlobal_);}

  bool IndicesAreLocal() const {return(CrsGraphData_->IndicesAreLocal_);}


  bool LowerTriangular() const {return(CrsGraphData_->LowerTriangular_);}


  bool UpperTriangular() const {return(CrsGraphData_->UpperTriangular_);}


  bool NoDiagonal() const {return(CrsGraphData_->NoDiagonal_);}

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool MyGlobalRow(int GID) const {return(RowMap().MyGID(GID));}
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool MyGlobalRow(long long GID) const {return(RowMap().MyGID(GID));}
#endif


  bool HaveColMap() const {return(CrsGraphData_->HaveColMap_);}



  int NumMyRows() const {return(CrsGraphData_->NumMyRows_);}

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalRows() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalRows64();
      throw "Epetra_CrsGraph::NumGlobalRows: GlobalIndices not int.";
    }
#endif
  long long NumGlobalRows64() const {return(CrsGraphData_->NumGlobalRows_);}


  int NumMyCols() const {return(CrsGraphData_->NumMyCols_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalCols() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalCols64();
      throw "Epetra_CrsGraph::NumGlobalCols: GlobalIndices not int.";
    }
#endif
  long long NumGlobalCols64() const {return(CrsGraphData_->NumGlobalCols_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalNonzeros() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalNonzeros64();
      throw "Epetra_CrsGraph::NumGlobalNonzeros: GlobalIndices not int.";
    }
#endif
  long long NumGlobalNonzeros64() const {return(CrsGraphData_->NumGlobalNonzeros_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalDiagonals() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalDiagonals64();
      throw "Epetra_CrsGraph::NumGlobalDiagonals: GlobalIndices not int.";
    }
#endif
  long long NumGlobalDiagonals64() const {return(CrsGraphData_->NumGlobalDiagonals_);}


  int NumMyDiagonals() const {return(CrsGraphData_->NumMyDiagonals_);}

  int NumMyBlockRows() const {return(CrsGraphData_->NumMyBlockRows_);}

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalBlockRows() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalBlockRows64();
      throw "Epetra_CrsGraph::NumGlobalBlockRows: GlobalIndices not int.";
    }
#endif
  long long NumGlobalBlockRows64() const {return(CrsGraphData_->NumGlobalBlockRows_);}


  int NumMyBlockCols() const {return(CrsGraphData_->NumMyBlockCols_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalBlockCols() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalBlockCols64();
      throw "Epetra_CrsGraph::NumGlobalBlockCols: GlobalIndices not int.";
    }
#endif
  long long NumGlobalBlockCols64() const {return(CrsGraphData_->NumGlobalBlockCols_);}


  int NumMyBlockDiagonals() const {return(CrsGraphData_->NumMyBlockDiagonals_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalBlockDiagonals() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalBlockDiagonals64();
      throw "Epetra_CrsGraph::NumGlobalBlockDiagonals: GlobalIndices not int.";
    }
#endif
  long long NumGlobalBlockDiagonals64() const {return(CrsGraphData_->NumGlobalBlockDiagonals_);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  NumGlobalEntries() const {
      if(RowMap().GlobalIndicesInt())
        return (int) NumGlobalEntries64();
      throw "Epetra_CrsGraph::NumGlobalEntries: GlobalIndices not int.";
    }
#endif
  long long NumGlobalEntries64() const {return(CrsGraphData_->NumGlobalEntries_);}


  int NumMyEntries() const {return(CrsGraphData_->NumMyEntries_);}

  int MaxRowDim() const {return(CrsGraphData_->MaxRowDim_);}


  int GlobalMaxRowDim() const {return(CrsGraphData_->GlobalMaxRowDim_);}


  int MaxColDim() const {return(CrsGraphData_->MaxColDim_);}


  int GlobalMaxColDim() const {return(CrsGraphData_->GlobalMaxColDim_);}


  int NumMyNonzeros() const {return(CrsGraphData_->NumMyNonzeros_);}

  int NumGlobalIndices(long long Row) const;

  int NumAllocatedGlobalIndices(long long Row) const;


  int MaxNumIndices() const {return(CrsGraphData_->MaxNumIndices_);}


  int GlobalMaxNumIndices() const {return(CrsGraphData_->GlobalMaxNumIndices_);}


  int MaxNumNonzeros() const {return(CrsGraphData_->MaxNumNonzeros_);}


  int GlobalMaxNumNonzeros() const {return(CrsGraphData_->GlobalMaxNumNonzeros_);}

  int NumMyIndices(int Row) const {if (Row<0 || Row >= NumMyRows()) return(0);
    if (StorageOptimized()) return(CrsGraphData_->IndexOffset_[Row+1] - CrsGraphData_->IndexOffset_[Row]);
    else return(CrsGraphData_->NumIndicesPerRow_[Row]);}

  int NumAllocatedMyIndices(int Row) const {if (Row<0 || Row >= NumMyRows()) return(0);
    if (StorageOptimized()) return(CrsGraphData_->IndexOffset_[Row+1] - CrsGraphData_->IndexOffset_[Row]);
    else return(CrsGraphData_->NumAllocatedIndicesPerRow_[Row]);}

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  IndexBase() const {
    if(RowMap().GlobalIndicesInt())
      return (int) IndexBase64();
    throw "Epetra_CrsGraph::IndexBase: GlobalIndices not int.";
  }
#endif
  long long  IndexBase64() const {return(CrsGraphData_->IndexBase_);};

  const Epetra_BlockMap& RowMap() const {return(Epetra_DistObject::Map());}

  int ReplaceRowMap(const Epetra_BlockMap& newmap);

  int ReplaceColMap(const Epetra_BlockMap& newmap);


  int ReplaceDomainMapAndImporter(const Epetra_BlockMap& NewDomainMap, const Epetra_Import * NewImporter);


  int RemoveEmptyProcessesInPlace(const Epetra_BlockMap * NewMap);



  const Epetra_BlockMap& ColMap() const {return(CrsGraphData_->ColMap_);}


  const Epetra_BlockMap& DomainMap() const {return(CrsGraphData_->DomainMap_);}


  const Epetra_BlockMap& RangeMap() const {return(CrsGraphData_->RangeMap_);}

  const Epetra_Import* Importer() const {return(CrsGraphData_->Importer_);}

  const Epetra_Export* Exporter() const {return(CrsGraphData_->Exporter_);}

  const Epetra_Comm& Comm() const {return(Epetra_DistObject::Comm());}



#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int LRID(int GRID_in) const {return(RowMap().LID(GRID_in));}
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int LRID(long long GRID_in) const {return(RowMap().LID(GRID_in));}
#endif

#if defined(EPETRA_NO_32BIT_GLOBAL_INDICES) && defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
  // default implementation so that no compiler/linker error in case neither 32 nor 64
  // bit indices present.
  int LRID(long long GRID_in) const {return(RowMap().LID(GRID_in));}
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  GRID(int LRID_in) const {
      if(RowMap().GlobalIndicesInt())
        return (int) GRID64(LRID_in);
      throw "Epetra_CrsGraph::GRID: GlobalIndices not int.";
    }
#endif
  long long GRID64(int LRID_in) const {return(RowMap().GID64(LRID_in));}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int LCID(int GCID_in) const
    {
      return( CrsGraphData_->HaveColMap_ ? ColMap().LID(GCID_in) : -1 );
    }
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int LCID(long long GCID_in) const
    {
      return( CrsGraphData_->HaveColMap_ ? ColMap().LID(GCID_in) : -1 );
    }
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    int  GCID(int LCID_in) const {
      if(RowMap().GlobalIndicesInt())
        return (int) GCID64(LCID_in);
      throw "Epetra_CrsGraph::GCID: GlobalIndices not int.";
    }
#endif
  long long GCID64(int LCID_in) const
    {
      return( CrsGraphData_->HaveColMap_ ? ColMap().GID64(LCID_in) : -1 );
    }

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool MyGRID(int GRID_in) const {return(LRID(GRID_in) != -1);}
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool MyGRID(long long GRID_in) const {return(LRID(GRID_in) != -1);}
#endif

  bool MyLRID(int LRID_in) const {return(GRID64(LRID_in) != IndexBase64() - 1);}


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool MyGCID(int GCID_in) const {return(LCID(GCID_in) != -1);}
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool MyGCID(long long GCID_in) const {return(LCID(GCID_in) != -1);}
#endif


  bool MyLCID(int LCID_in) const {return(GCID64(LCID_in) != IndexBase64() - 1);}




  inline int*  operator[]( int Loc ) {
    if (StorageOptimized()){ return(CrsGraphData_->data->All_Indices_.Values() + CrsGraphData_->IndexOffset_[Loc]);}
    else return(CrsGraphData_->data->Indices_[Loc]); }

  inline int* operator[]( int Loc ) const {
    if (StorageOptimized()) { return(CrsGraphData_->data->All_Indices_.Values() +CrsGraphData_->IndexOffset_[Loc]);}
    else return(CrsGraphData_->data->Indices_[Loc]); }



  Epetra_CrsGraph& operator = (const Epetra_CrsGraph& Source);



  virtual void Print(std::ostream& os) const;

  void PrintGraphData(std::ostream& os) const {CrsGraphData_->Print(os);}
  void PrintGraphData(std::ostream& os, int level) const {CrsGraphData_->Print(os, level);}



  const Epetra_BlockMap& ImportMap() const {return(CrsGraphData_->ColMap_);}

  int TransformToLocal();

  int TransformToLocal(const Epetra_BlockMap* DomainMap, const Epetra_BlockMap* RangeMap);





  int ReferenceCount() const {return(CrsGraphData_->ReferenceCount());}


  const Epetra_CrsGraphData* DataPtr() const {return(CrsGraphData_);}
  


  Epetra_IntSerialDenseVector& ExpertExtractIndexOffset(); 


  Epetra_IntSerialDenseVector& ExpertExtractIndices();



        void SortGhostsAssociatedWithEachProcessor(bool Flag) {CrsGraphData_->SortGhostsAssociatedWithEachProcessor_ = Flag;}


  // functions listed in protected are the ones used by CrsMatrix and VbrMatrix.
  // functions listed in private are the ones that are really private.
  // (just pretend CrsMatrix and VbrMatrix derive from CrsGraph to understand the distinction.)
  friend class Epetra_CrsMatrix;
  friend class Epetra_VbrMatrix;
  friend class Epetra_FECrsGraph;
  friend class Epetra_FECrsMatrix;
  friend class Epetra_FEVbrMatrix;
  friend class Epetra_OffsetIndex;

 protected:
  int *All_Indices() const {
    if (!StorageOptimized()) throw ReportError("This method: int *All_Indices() cannot be called when StorageOptimized()==false", -1);
    else return(CrsGraphData_->data->All_Indices_.Values());}
#if defined(Epetra_ENABLE_MKL_SPARSE) && !defined(Epetra_DISABLE_MKL_SPARSE_MM)
  int *All_IndicesPlus1() const;
#endif
  int *IndexOffset() const {
    if (!StorageOptimized()) throw ReportError("This method: int *IndexOffset()  cannot be called when StorageOptimized()==false", -1);
    else return(CrsGraphData_->IndexOffset_.Values());}
  int* NumIndicesPerRow() const {
    if (StorageOptimized()) throw ReportError("This method: int* NumIndicesPerRow() cannot be called when StorageOptimized()==true", -1);
    else return(CrsGraphData_->NumIndicesPerRow_.Values());}
  int* NumAllocatedIndicesPerRow() const {
    if (StorageOptimized()) throw ReportError("This method: int* NumAllocatedIndicesPerRow() cannot be called when StorageOptimized()==true", -1);
    else return(CrsGraphData_->NumAllocatedIndicesPerRow_.Values());}
  int** Indices() const {
    if (StorageOptimized()) throw ReportError("This method: int** Indices() cannot be called when StorageOptimized()==true", -1);
    else return(CrsGraphData_->data->Indices_);}
  int* Indices(int LocalRow) const {
    if (StorageOptimized()) return(CrsGraphData_->data->All_Indices_.Values()+CrsGraphData_->IndexOffset_[LocalRow]);
    else return(CrsGraphData_->data->Indices_[LocalRow]);}

  template<typename int_type>
  int_type** TIndices() const {
    if (StorageOptimized()) throw ReportError("This method: int_type** TIndices() cannot be called when StorageOptimized()==true", -1);
    else return(CrsGraphData_->Data<int_type>().Indices_);}

  template<typename int_type>
  int_type* TIndices(int LocalRow) const {
    if (StorageOptimized()) return(CrsGraphData_->Data<int_type>().All_Indices_.Values()+CrsGraphData_->IndexOffset_[LocalRow]);
    else return(CrsGraphData_->Data<int_type>().Indices_[LocalRow]);}

  // If column indices are stored in one long array (via a call to OptimizeStorage),
  // IndicesAreContiguous returns true, otherwise it returns false.
  bool IndicesAreContiguous() const {return(CrsGraphData_->IndicesAreContiguous_);}
  bool StaticProfile() const {return(CrsGraphData_->StaticProfile_);}
  bool GlobalConstantsComputed() const;
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool FindGlobalIndexLoc(int LocalRow, int Index, int Start, int& Loc) const;
  bool FindGlobalIndexLoc(int NumIndices, const int* Indices, int Index, int Start, int& Loc) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool FindGlobalIndexLoc(int LocalRow, long long Index, int Start, int& Loc) const;
  bool FindGlobalIndexLoc(int NumIndices, const long long* Indices, long long Index, int Start, int& Loc) const;
#endif

  bool FindMyIndexLoc(int LocalRow, int Index, int Start, int& Loc) const;
  bool FindMyIndexLoc(int NumIndices, const int* Indices, int Index, int Start, int& Loc) const;

  int InsertIndices(int Row, int NumIndices, int* Indices);
  int InsertIndicesIntoSorted(int Row, int NumIndices, int* Indices);

  int InsertIndices(int Row, int NumIndices, long long* Indices);
  int InsertIndicesIntoSorted(int Row, int NumIndices, long long* Indices);

  int MakeIndicesLocal(const Epetra_BlockMap& DomainMap, const Epetra_BlockMap& RangeMap);
  void SetIndicesAreLocal(bool Flag) {CrsGraphData_->IndicesAreLocal_ = Flag;}
  void SetIndicesAreGlobal(bool Flag) {CrsGraphData_->IndicesAreGlobal_ = Flag;}
  void SetSorted(bool Flag) {CrsGraphData_->Sorted_ = Flag;}



  int SortIndices();

  bool Sorted() const {return(CrsGraphData_->Sorted_);}


  int RemoveRedundantIndices();
  int DetermineTriangular();

  bool NoRedundancies() const {return(CrsGraphData_->NoRedundancies_);}

 private:
  void SetGlobalConstantsComputed(bool Flag) {CrsGraphData_->GlobalConstantsComputed_ = Flag;}
  void SetIndicesAreContiguous(bool Flag) {CrsGraphData_->IndicesAreContiguous_ = Flag;}
  void SetNoRedundancies(bool Flag) {CrsGraphData_->NoRedundancies_ = Flag;}
  void ComputeIndexState();
  int MakeColMap(const Epetra_BlockMap& DomainMap, const Epetra_BlockMap& RangeMap);
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int MakeColMap_int(const Epetra_BlockMap& DomainMap, const Epetra_BlockMap& RangeMap);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int MakeColMap_LL (const Epetra_BlockMap& DomainMap, const Epetra_BlockMap& RangeMap);
#endif
  int Allocate(const int* NumIndicesPerRow, int Inc, bool StaticProfile);
  //int ReAllocate();
  int ComputeGlobalConstants();
  void SetFilled(bool Flag) {CrsGraphData_->Filled_ = Flag;}
  bool Allocated() const {return(CrsGraphData_->Allocated_);}
  void SetAllocated(bool Flag) {CrsGraphData_->Allocated_ = Flag;}

  int CheckSizes(const Epetra_SrcDistObject& A);

  int CopyAndPermute(const Epetra_SrcDistObject& Source,
                           int NumSameIDs,
                           int NumPermuteIDs,
                           int* PermuteToLIDs,
                           int* PermuteFromLIDs,
                           const Epetra_OffsetIndex * Indexor,
                           Epetra_CombineMode CombineMode = Zero);
  int CopyAndPermuteRowMatrix(const Epetra_RowMatrix& A,
                                    int NumSameIDs,
                                    int NumPermuteIDs,
                                    int* PermuteToLIDs,
                                    int* PermuteFromLIDs,
                                    const Epetra_OffsetIndex * Indexor,
                                    Epetra_CombineMode CombineMode);

  template<typename int_type>
  int CopyAndPermuteRowMatrix(const Epetra_RowMatrix& A,
                                    int NumSameIDs,
                                    int NumPermuteIDs,
                                    int* PermuteToLIDs,
                                    int* PermuteFromLIDs,
                                    const Epetra_OffsetIndex * Indexor,
                                    Epetra_CombineMode CombineMode);

  int CopyAndPermuteCrsGraph(const Epetra_CrsGraph& A,
                                   int NumSameIDs,
                                   int NumPermuteIDs,
                                   int* PermuteToLIDs,
                                   int* PermuteFromLIDs,
                                   const Epetra_OffsetIndex * Indexor,
                                   Epetra_CombineMode CombineMode);

  template<typename int_type>
  int CopyAndPermuteCrsGraph(const Epetra_CrsGraph& A,
                                   int NumSameIDs,
                                   int NumPermuteIDs,
                                   int* PermuteToLIDs,
                                   int* PermuteFromLIDs,
                                   const Epetra_OffsetIndex * Indexor,
                                   Epetra_CombineMode CombineMode);

        int PackAndPrepare(const Epetra_SrcDistObject& Source,
                           int NumExportIDs,
                           int* ExportLIDs,
                           int& LenExports,
                           char*& Exports,
                           int& SizeOfPacket,
                           int * Sizes,
                           bool & VarSizes,
                           Epetra_Distributor& Distor);
        int PackAndPrepareCrsGraph(const Epetra_CrsGraph& A,
                                   int NumExportIDs,
                                   int* ExportLIDs,
                                   int& LenExports,
                                   char*& Exports,
                                   int& SizeOfPacket,
                                   int* Sizes,
                                   bool& VarSizes,
                                   Epetra_Distributor& Distor);
        int PackAndPrepareRowMatrix(const Epetra_RowMatrix& A,
                                    int NumExportIDs,
                                    int* ExportLIDs,
                                    int& LenExports,
                                    char*& Exports,
                                    int& SizeOfPacket,
                                    int* Sizes,
                                    bool& VarSizes,
                                    Epetra_Distributor& Distor);

        int UnpackAndCombine(const Epetra_SrcDistObject& Source,
                             int NumImportIDs,
                             int* ImportLIDs,
                             int LenImports,
                             char* Imports,
                             int& SizeOfPacket,
                             Epetra_Distributor& Distor,
                             Epetra_CombineMode CombineMode,
                             const Epetra_OffsetIndex * Indexor);

  void CleanupData();

  Epetra_CrsGraphData* CrsGraphData_;

private:

  template<typename int_type>
  int TAllocate(const int* numIndicesPerRow, int Inc, bool staticProfile);

  template<typename int_type>
  int InsertGlobalIndices(int_type GlobalRow, int NumIndices, int_type* Indices);

  template<typename int_type>
  int TInsertIndices(int Row, int NumIndices, int_type* Indices);

  template<typename int_type>
  int TInsertIndicesIntoSorted(int Row, int NumIndices, int_type* Indices);

  template<typename int_type>
  int RemoveGlobalIndices(int_type GlobalRow, int NumIndices, int_type* Indices);

  template<typename int_type>
  int TRemoveGlobalIndices(long long Row);

  template<typename int_type>
  bool FindGlobalIndexLoc(int LocalRow, int_type Index, int Start, int& Loc) const;

  template<typename int_type>
  bool FindGlobalIndexLoc(int NumIndices, const int_type* Indices, int_type Index, int Start, int& Loc) const;

  template<typename int_type>
  int ExtractGlobalRowCopy(int_type Row, int LenOfIndices, int& NumIndices, int_type* Indices) const;

  template<typename int_type>
  int ExtractMyRowCopy(int Row, int LenOfIndices, int& NumIndices, int_type* targIndices) const;
};
#endif /* EPETRA_CRSGRAPH_H */

#if defined(Epetra_SHOW_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#warning "The Epetra package is deprecated"
#endif
#endif