table.hpp

Go to the documentation of this file.

// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
// reserved. See file COPYRIGHT for details.
//
// This file is part of the MFEM library. For more information and source code
// availability see http://mfem.org.
//
// MFEM is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License (as published by the Free
// Software Foundation) version 2.1 dated February 1999.

#ifndef MFEM_TABLE
#define MFEM_TABLE

// Data types for Table.

#include "mem_alloc.hpp"
#include "array.hpp"

namespace mfem
{

struct Connection
{
   int from, to;
   Connection(int from, int to) : from(from), to(to) {}

   bool operator== (const Connection &rhs) const
   { return (from == rhs.from) && (to == rhs.to); }
   bool operator< (const Connection &rhs) const
   { return (from == rhs.from) ? (to < rhs.to) : (from < rhs.from); }
};


class Table
{
protected:

   int size;

   int *I, *J;

public:
   Table() { size = -1; I = J = NULL; }

   Table(const Table &);

   explicit Table (int dim, int connections_per_row = 3);

   Table(int nrows, Array<Connection> &list) : size(-1), I(NULL), J(NULL)
   { MakeFromList(nrows, list); }

   Table (int nrows, int *partitioning);

   void MakeI (int nrows);
   void AddAColumnInRow (int r) { I[r]++; }
   void AddColumnsInRow (int r, int ncol) { I[r] += ncol; }
   void MakeJ();
   void AddConnection (int r, int c) { J[I[r]++] = c; }
   void AddConnections (int r, const int *c, int nc);
   void ShiftUpI();

   void SetSize(int dim, int connections_per_row);

   void SetDims(int rows, int nnz);

   inline int Size() const { return size; }

   inline int Size_of_connections() const { return I[size]; }

   int operator() (int i, int j) const;

   void GetRow(int i, Array<int> &row) const;

   int RowSize(int i) const { return I[i+1]-I[i]; }

   const int *GetRow(int i) const { return J+I[i]; }
   int *GetRow(int i) { return J+I[i]; }

   int *GetI() { return I; }
   int *GetJ() { return J; }
   const int *GetI() const { return I; }
   const int *GetJ() const { return J; }

   void SetIJ(int *newI, int *newJ, int newsize = -1);

   int Push( int i, int j );

   void Finalize();

   void MakeFromList(int nrows, const Array<Connection> &list);

   int Width() const;

   void LoseData() { size = -1; I = J = NULL; }

   void Print(std::ostream & out = std::cout, int width = 4) const;
   void PrintMatlab(std::ostream & out) const;

   void Save(std::ostream & out) const;
   void Copy(Table & copy) const;
   void Swap(Table & other);

   void Clear();

   long MemoryUsage() const;

   ~Table();
};

template <> inline void Swap<Table>(Table &a, Table &b)
{
   a.Swap(b);
}

void Transpose (const Table &A, Table &At, int _ncols_A = -1);
Table * Transpose (const Table &A);

void Transpose(const Array<int> &A, Table &At, int _ncols_A = -1);

void Mult (const Table &A, const Table &B, Table &C);
Table * Mult (const Table &A, const Table &B);


class STable : public Table
{
public:
   STable (int dim, int connections_per_row = 3);

   int operator() (int i, int j) const;

   int Push( int i, int j );

   ~STable() {}
};


class DSTable
{
private:
   class Node
   {
   public:
      Node *Prev;
      int  Column, Index;
   };

   int  NumRows, NumEntries;
   Node **Rows;
#ifdef MFEM_USE_MEMALLOC
   MemAlloc <Node, 1024> NodesMem;
#endif

   int Push_(int r, int c);
   int Index(int r, int c) const;

public:
   DSTable(int nrows);
   int NumberOfRows() const { return (NumRows); }
   int NumberOfEntries() const { return (NumEntries); }
   int Push(int a, int b)
   { return ((a <= b) ? Push_(a, b) : Push_(b, a)); }
   int operator()(int a, int b) const
   { return ((a <= b) ? Index(a, b) : Index(b, a)); }
   ~DSTable();

   class RowIterator
   {
   private:
      Node *n;
   public:
      RowIterator (const DSTable &t, int r) { n = t.Rows[r]; }
      int operator!() { return (n != NULL); }
      void operator++() { n = n->Prev; }
      int Column() { return (n->Column); }
      int Index() { return (n->Index); }
   };
};

}

#endif