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 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); }

  // 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 QList<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;

#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