gmSparseMatrix.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together 
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND, 
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR 
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_SPARSE_MATRIX_H_
#define _GEMA_SPARSE_MATRIX_H_
 
#include "gmSolverMatrix.h"
#include "gmSparseMatrixTripletData.h"
#include "gmSparseMatrixOptions.h"
#include "gmThreadManager.h"
 
class GmSimulationData;
class LuaTable;
 
class GMC_API_EXPORT GmSparseMatrixBase : public QObject, public GmSolverMatrix
{
  Q_OBJECT
 
protected slots:
  virtual void matrixLayoutReady() = 0;
};
 
template<class IndexType, GmSparseMatrixLayoutTypes T>
class GMC_API_EXPORT GmSparseMatrix : public GmSparseMatrixBase
{
public:
 
  GmSparseMatrix(int n, const GmSparseMatrix<IndexType, T>* sharedLayout, 
                 GmSparseMatrixOptions options, bool arma);
  virtual ~GmSparseMatrix();
 
  // See comments on the base class
  virtual bool supportsBatchInsert() const { return _opt.mode() == GM_TRIPLET_LIST; }
 
  // See comments on the base class
  virtual bool supportsSparseLayouts() const { return _opt.mode() != GM_TRIPLET_LIST; }
 
  // See comments on the base class
  virtual bool supportsRandomSet() const { return false; }
 
  // See comments on the base class
  virtual ParallelAddMode supportedParallelAddMode() const 
  { 
    return (_opt.mode() == GM_TRIPLET_LIST) ? THREAD_SAFE_SUPPORT : REENTRANT_SUPPORT; 
  }
 
  virtual bool beginBatchInsert(size_t expectedEntries = 0);
  virtual bool endBatchInsert(bool discardData = false);
 
  // See comments on the base class
  virtual GmSparseMatrixLayoutBuilder* layoutBuilder() const { assert(GmThreadManager::inMainThread()); return _layoutBuilder; }
 
  // See comments on the base class
  virtual bool emptyLayout() const 
  { 
    assert(GmThreadManager::inMainThread()); 
    return (_opt.mode() == GM_TRIPLET_LIST) ? false : _layout->empty();
  }
 
  // See comments on the base class
  virtual bool symmetric() const { return _sym.loadAcquire(); }
 
  // See comments on the base class
  virtual void setSymmetric(bool sym) { _sym.storeRelease(sym); }
 
  virtual bool isSymmetric(double relTol = GM_DOUBLECMP_RELTOL, double absTol = GM_DOUBLECMP_ABSTOL) const;
 
  // See comments on the base class
  virtual int nlin() const { return _n; }
 
  // See comments on the base class
  virtual int ncol() const { return _n; }
 
  // See comments on the base class
  virtual int layoutSize() const { assert(GmThreadManager::inMainThread()); assert(_layout); return _layout->_nnz; }
 
  // See comments on the base class
  virtual double at(int lin, int col) const
  { 
    assert(GmThreadManager::inMainThread());
    assert(_layout);  
    assert(lin >= 0 && lin < _n);
    assert(col >= 0 && col < _n);
    assert(!_batch);
 
    if(_layout->empty())
      return 0.0;
 
    int index = _layout->index(lin, col);
    assert(index >= -1 && index < _layout->_nnz);
 
    return index >= 0 ? _values[index] : 0.0;
  }
 
  // See comments on the base class
  virtual bool inLayout(int lin, int col) const
  {
    assert(GmThreadManager::inMainThread());
    assert(_layout);
    assert(lin >= 0 && lin < _n);
    assert(col >= 0 && col < _n);
    assert(!_batch);
 
    if(_layout->empty())
      return false;
    return (_layout->index(lin, col) >= 0);
  }
 
  // See comments on the base class
  virtual void set(int lin, int col, double value)
  {
    assert(GmThreadManager::inMainThread());
    assert(_layout && !_layout->empty());
    assert(lin >= 0 && lin < _n);
    assert(col >= 0 && col < _n);
    assert(!_batch);
 
    int index = _layout->index(lin, col);
    assert(index >= 0 && index < _layout->_nnz); // This matrix does not support random sets
 
    _values[index] = value;
  }
 
  // See comments on the base class
  virtual void add(int lin, int col, double value)
  {
    assert(_batch || (_layout && !_layout->empty()));
    assert(lin >= 0 && lin < _n);
    assert(col >= 0 && col < _n);
 
    if(_batch)
      addBatch(lin, col, value);
    else
    {
      if(value == 0.0)
        return;
 
      int index = _layout->index(lin, col);
      assert(index >= 0 && index < _layout->_nnz); // This matrix does not support random sets
      _values[index] += value;
    }
  }
 
  virtual void set(GmSolverMatrix* A, GmSolverMatrix* B, double c, bool sameStructure);
 
  virtual void clear(bool keepSparseLayout);
 
  virtual void clearLineAndColumnSet(const QVector<int>& indexList, bool setDiagonal, bool keepSparseLayout);
 
  virtual void ensureDiagonal();
 
  virtual void matAdd(const GmVector& a, const GmVector& b, double zeroTol = 0.0);
 
  virtual void mul(const GmVector& a, GmVector& b) const;
 
  virtual void mulAdd(const GmVector& a, GmVector& b) const;
 
  virtual void mulSub(const GmVector& a, GmVector& b) const;
 
  virtual void columnMulAdd(int col, GmVector& f, double v, const bool* skipRows = NULL) const;
 
  virtual size_t usedMemory() const;
 
  // See comments on the base class
  virtual bool hasNanInf() const
  {
    for(int i=0; i<_layout->_nnz; i++) 
    {
      if(std::isnan(_values[i]) || std::isinf(_values[i]))
        return true;
          }
    return false;
  }
 
  virtual bool saveMatrixCoordinatesToFile(FILE* f) const;
 
#ifdef ENABLE_TESTS
  virtual void checkLayoutData() const;
#endif
 
private:
  Q_DISABLE_COPY(GmSparseMatrix);
 
protected:
  virtual void matrixLayoutReady();
 
  void addBatch(int lin, int col, double value);
  void addToPtrIndexFromThread(int tid, int ptr, int index, double value);
 
  virtual GmSparseMatrix<IndexType, T>* detachAndClear();
  GmSparseMatrixLayoutBuilder*  createLayoutBuilder(GmSparseMatrixLayoutMode mode, GmCSxSparseMatrixLayout<IndexType, T>* layout);
 
  GmSparseMatrixOptions _opt;   
  bool                  _batch;  
  int                   _n;      
  QAtomicInt            _sym;    
  double*               _values; 
 
  const GmCSxSparseMatrixLayout<IndexType, T>* _layout;       
  GmCSxSparseMatrixLayout<IndexType, T>*       _masterLayout; 
 
  GmSparseMatrixLayoutBuilder*  _layoutBuilder; 
 
  GmSparseMatrixTripletBuffer<T>* _batchData; 
};
 
#endif