oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE > Class Template Reference

#include <map_matrix.h>

Inheritance diagram for oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >:

Public Types
typedef std::map< KEY_TYPE_COL, VALUE_TYPE >	InnerMapMixed
	Typedef to keep the code more readable. More...
typedef InnerMapMixed::iterator	InnerMixedIt
	Typedef to keep the code more readable. More...
typedef InnerMapMixed::const_iterator	ConstInnerMixedIt
	Typedef to keep the code more readable const version. More...
typedef std::map< KEY_TYPE_ROW, std::map< KEY_TYPE_COL, VALUE_TYPE > * >	OuterMapMixed
	Typedef to keep the code more readable. More...
typedef OuterMapMixed::iterator	OuterMixedIt
	Typedef to keep the code more readable. More...
typedef OuterMapMixed::const_iterator	ConstOuterMixedIt
	Typedef to keep the code more readable const version. More...

Public Member Functions
	MapMatrixMixed ()
	Default (empty) constructor. More...
void	operator= (const MapMatrixMixed &)=delete
	Broken assignment operator. More...
	MapMatrixMixed (const MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE > &map_mat)
	Copy constructor. More...
void	copy_column (const KEY_TYPE_COL &j, std::map< KEY_TYPE_ROW, VALUE_TYPE > &copied_map)
	Copy a single column into its own map. More...
virtual	~MapMatrixMixed ()
	Destructor. More...
void	clear ()
	Wipe all entries. More...
VALUE_TYPE &	operator() (const KEY_TYPE_ROW &i, const KEY_TYPE_COL &j)
VALUE_TYPE	get (const KEY_TYPE_ROW &i, const KEY_TYPE_COL &j) const
void	output (std::ostream &outfile)
unsigned long	nnz ()
	Work out number of non-‘zero’ entries. More...
unsigned long	nnz () const
	Work out number of non-‘zero’ entries, const version. More...
unsigned long	size ()
	Work out total number of entries. More...
unsigned long	size () const
	Work out total number of entries const version. More...

Protected Member Functions
VALUE_TYPE *	entry_pt (const KEY_TYPE_ROW &i, const KEY_TYPE_COL &j)
	Return pointer to entry. More...

Protected Attributes
std::map< KEY_TYPE_ROW, std::map< KEY_TYPE_COL, VALUE_TYPE > * >	Row_pt

Detailed Description

template<class KEY_TYPE_ROW, class KEY_TYPE_COL, class VALUE_TYPE>
class oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >

MapMatrixMixed is a generalised, STL-map-based, sparse(ish) matrix class with mixed indices

The matrix is indexed by indices of type KEY_TYPE_ROW and KEY_TYPE_COL and has entries of type VALUE_TYPE.

Careful: If a zero entry is referenced then it is created in memory. Therefore this isn't really a practical sparse matrix scheme. Do not loop over ‘all’ possible indices as even looking at them will inflate the matrix until it occupies as much space as a full one – use (modification of) output routine to retrieve all nonzero entries.

However, this is not a serious restriction, as the main purpose of this class is to allow non-integer indices.

Example of usage:

 // Assume we have a Vector of pointers to objects:
 Vector<Rubbish*> object_pt;
 
 [...]
 
 // Number of objects
 int nentry=object_pt.size();
 
 // Use the pointers to the objects and associated integers as indices
 // in a MapMatrixMixed whose entries are of type int
 MapMatrixMixed<Rubbish*,int,int> like_a_matrix;
 
 for (int i=1;i<nentry;i++)
  {
   for (int j=1;j<nentry;j++)
    {
     int number=100*i+j;
     like_a_matrix(object_pt[i],j)=number;
    }
  }
 
 oomph_info << "Matrix has nnz() " << like_a_matrix.nnz() <<
         " and size() " << like_a_matrix.size() << std::endl;
 
 oomph_info << "\n\n\n Here are the nonzero entries: i, j, a(i,j)\n";
 
 like_a_matrix.output(oomph_info);
 
 // Can be used like a normal matrix:
 like_a_matrix(object_pt[1],20)+=13;
 like_a_matrix(object_pt[1],1)+=13;
 
 oomph_info << "\n\n\n Here are the nonzero entries: i, j, a(i,j)\n";
like_a_matrix.output(oomph_info);

Member Typedef Documentation

ConstInnerMixedIt

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef InnerMapMixed::const_iterator oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::ConstInnerMixedIt

Typedef to keep the code more readable const version.

ConstOuterMixedIt

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef OuterMapMixed::const_iterator oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::ConstOuterMixedIt

Typedef to keep the code more readable const version.

InnerMapMixed

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef std::map<KEY_TYPE_COL, VALUE_TYPE> oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::InnerMapMixed

Typedef to keep the code more readable.

InnerMixedIt

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef InnerMapMixed::iterator oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::InnerMixedIt

Typedef to keep the code more readable.

OuterMapMixed

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef std::map<KEY_TYPE_ROW, std::map<KEY_TYPE_COL, VALUE_TYPE>*> oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::OuterMapMixed

Typedef to keep the code more readable.

OuterMixedIt

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

typedef OuterMapMixed::iterator oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::OuterMixedIt

Typedef to keep the code more readable.

Constructor & Destructor Documentation

MapMatrixMixed() [1/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::MapMatrixMixed ( )

inline

Default (empty) constructor.

{};

MapMatrixMixed() [2/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::MapMatrixMixed ( const MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE > &  map_mat )

inline

Copy constructor.

    {
      // Step through the row pointers
      for (ConstOuterMixedIt it = map_mat.Row_pt.begin();
           it != map_mat.Row_pt.end();
           it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Copy
            if (it2->second != 0)
            {
              // key1, key2, value
              (*this)(it->first, it2->first) = it2->second;
            }
          }
        }
      }
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

~MapMatrixMixed()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

virtual oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::~MapMatrixMixed ( )

inlinevirtual

Destructor.

    {
      // Step through the pointers to row maps
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // it->second is the stored object
          delete it->second;
        }
      }
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

Member Function Documentation

clear()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

void oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::clear ( )

inline

Wipe all entries.

    {
      // Step through the pointers to row maps
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // it->second is the stored object: a map which can be cleared!
          it->second->clear();
        }
      }
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

copy_column()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

void oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::copy_column ( const KEY_TYPE_COL &  j, std::map< KEY_TYPE_ROW, VALUE_TYPE > &  copied_map  )

inline

Copy a single column into its own map.

    {
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
          // If the desired column of the inner map is non-zero
          if (inner_map[j] != 0)
          {
            // Set the value of the copied map to be the desired column of the
            // inner map
            copied_map[it->first] = inner_map[j];
          }
        }
      }
    }

References j, and oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

entry_pt()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

VALUE_TYPE* oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::entry_pt ( const KEY_TYPE_ROW &  i, const KEY_TYPE_COL &  j  )

inlineprotected

Return pointer to entry.

    {
      // There's not a single entry in this row: Entry must be zero.
      if (Row_pt[i] == 0)
      {
        // Create row and entry in row and set the value to zero
        Row_pt[i] = new std::map<KEY_TYPE_COL, VALUE_TYPE>;
        (*Row_pt[i])[j] = VALUE_TYPE(0);
        return &(*Row_pt[i])[j];
      }
      // Simply return pointer to existing entry
      else
      {
        return &(*Row_pt[i])[j];
      }
    }

References i, j, and oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

Referenced by oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::operator()().

get()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

VALUE_TYPE oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::get ( const KEY_TYPE_ROW &  i, const KEY_TYPE_COL &  j  ) const

inline

Get an element corresponding to the key (i,j) Searches the container for an element with a key equivalent to (i,j) and returns the element if found, otherwise the default 0 value for the value type is returned. The container is not modified.

    {
      if (Row_pt.count(i) > 0)
      {
        // Get the pointer to the row and check the j key
        InnerMapMixed* inner_map_mixed_pt = Row_pt.find(i)->second;
        if (inner_map_mixed_pt->count(j) > 0)
        {
          return inner_map_mixed_pt->find(j)->second;
        }
        else
        {
          return VALUE_TYPE(0);
        }
      }
      else
      {
        // The key does not exist, return VALUE_TYPE(0)
        return VALUE_TYPE(0);
      }
    }

References i, j, and oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

nnz() [1/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

unsigned long oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::nnz ( )

inline

Work out number of non-‘zero’ entries.

    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Increment counter
            if (it2->second != 0)
            {
              count++;
            }
          }
        }
      }
      return count;
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

nnz() [2/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

unsigned long oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::nnz ( ) const

inline

Work out number of non-‘zero’ entries, const version.

    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (ConstOuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Increment counter
            if (it2->second != 0)
            {
              count++;
            }
          }
        }
      }
      return count;
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

operator()()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

VALUE_TYPE& oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::operator() ( const KEY_TYPE_ROW &  i, const KEY_TYPE_COL &  j  )

inline

Return (reference to) entry. Careful: If the entry does not exist then it is created and set to zero

    {
      return *entry_pt(i, j);
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::entry_pt(), i, and j.

operator=()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

void oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::operator= ( const MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE > &  )

delete

Broken assignment operator.

output()

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

void oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::output ( std::ostream &  outfile )

inline

Dump all non-‘zero’ entries to file. Output is in the format ‘i’, ‘j’, ‘entry[i][j]’

    {
      // NOTE:
      //------
      // map.first = key
      // map.second = value
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Doc
            if (it2->second != 0)
            {
              // Output key1, key2, value
              outfile << it->first << " " << it2->first << " " << it2->second
                      << std::endl;
            }
          }
        }
      }
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

size() [1/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

unsigned long oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::size ( )

inline

Work out total number of entries.

    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over all (!) entries in the row (incl. zero ones!)
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            count++;
          }
        }
      }
      return count;
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

size() [2/2]

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

unsigned long oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::size ( ) const

inline

Work out total number of entries const version.

    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (ConstOuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over all (!) entries in the row (incl. zero ones!)
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            count++;
          }
        }
      }
      return count;
    }

References oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt.

Member Data Documentation

Row_pt

template<class KEY_TYPE_ROW , class KEY_TYPE_COL , class VALUE_TYPE >

std::map<KEY_TYPE_ROW, std::map<KEY_TYPE_COL, VALUE_TYPE>*> oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::Row_pt

protected

Here's the generalised matrix structure: A map of pointers to the maps that hold the entries in each row.

Referenced by oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::clear(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::copy_column(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::entry_pt(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::get(), oomph::MapMatrix< KEY_TYPE, VALUE_TYPE >::MapMatrix(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::MapMatrixMixed(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::nnz(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::output(), oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::size(), and oomph::MapMatrixMixed< KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE >::~MapMatrixMixed().

---

The documentation for this class was generated from the following file:

• map_matrix.h