AlephCudaMatrix.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* cnc_matrix.h                                                (C) 2000-2012 */
/*                                                                           */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef _CNC_INTERFACE_MATRIX_H_
#define _CNC_INTERFACE_MATRIX_H_
 
 
ARCANE_BEGIN_NAMESPACE
  
class CNCCoeff {
public:
  double a ;
  long index ;
} ;
 
//---------------------------------------------------------------------------//
 
class CNCCoeffIndexCompare {
public:
  bool operator()(const CNCCoeff& c1, const CNCCoeff& c2) {
    return c1.index < c2.index ;
  }
};
 
//---------------------------------------------------------------------------//
 
class CNCSparseRowColumn {
public:
  CNCSparseRowColumn() {
    coeff_ = CNCallocate<CNCCoeff>(2) ;
    nb_coeffs_ = 0 ;
    capacity_ = 2 ;
  }
  ~CNCSparseRowColumn() { CNCdeallocate<CNCCoeff>(coeff_) ;  }
  long nb_coeffs() const { return nb_coeffs_ ; }
  CNCCoeff& coeff(long ii) {return coeff_[ii] ; }
  const CNCCoeff& coeff(long ii) const {   return coeff_[ii] ;  }
  
  void add(long index, double val){
    CNCCoeff* coeff = NULL ;
    // Search for a_{index}
    for(long ii=0; ii < nb_coeffs_; ii++) {
      if(coeff_[ii].index == index) {
        coeff = &(coeff_[ii]) ;
        break ;
      }
    }
    if(coeff != NULL) {
//#warning add is set//
//      coeff->a += val ;
      coeff->a = val ;
    } else {
      nb_coeffs_++ ;
      if(nb_coeffs_ > capacity_) {
        grow() ;
      }
      coeff = &(coeff_[nb_coeffs_ - 1]) ;
      coeff->a = val ;
      coeff->index = index ;
    }
  }
            
  void sort() {
    CNCCoeff* begin = coeff_ ;
    CNCCoeff* end   = coeff_ + nb_coeffs_ ;
    std::sort(begin, end, CNCCoeffIndexCompare()) ;
  }
 
  void clear() { 
    CNCdeallocate<CNCCoeff>(coeff_) ;
    coeff_ = CNCallocate<CNCCoeff>(2) ;
    nb_coeffs_ = 0 ;
    capacity_ = 2 ;
  }
 
  void zero() { nb_coeffs_ = 0 ; }
 
protected:
  void grow(){
    long old_capacity = capacity_ ;
    capacity_ = capacity_ * 2 ;
    CNCreallocate<CNCCoeff>(coeff_, old_capacity, capacity_) ;
  }
  
private:
  CNCCoeff* coeff_ ;
  long nb_coeffs_ ;
  long capacity_ ;
} ;
 
 
//---------------------------------------------------------------------------//
 
 
class CNC_Matrix {
public:
 
  enum Storage {NONE, ROWS, COLUMNS, ROWS_AND_COLUMNS} ;
 
  // constructors / destructor
 
  CNC_Matrix(long m, long n, Storage storage = ROWS) ;
 
  CNC_Matrix(long n ) ;
 
  CNC_Matrix(long n, Storage storage, bool symmetric_storage) ;
 
  CNC_Matrix() ;
 
  ~CNC_Matrix() ;
 
  // access
 
  long m() const;
 
  long n() const ;
 
  long diag_size() const ;
 
  long nnz() const ;
 
  bool rows_are_stored() const;
 
  bool columns_are_stored() const ;
 
  Storage storage() const ;
 
  bool has_symmetric_storage() const ;
 
  bool is_square() const;
 
  bool is_symmetric() const ;
 
  void set_symmetric_tag(bool x);
  
  CNCSparseRowColumn& row(long i) ;
  const CNCSparseRowColumn& row(long i) const ;
  CNCSparseRowColumn& column(long j) ;
  const CNCSparseRowColumn& column(long j) const ;
 
 
  double diag(long i) const;
 
  void add(long i, long j, double val) ;
            
 
  void sort() ;
            
 
  void clear() ;
 
  void zero() ;
 
  void allocate(long m, long n, Storage storage, bool symmetric = false) ;
 
  void deallocate() ;
 
private:
  long m_ ;
  long n_ ;
  long diag_size_ ;
 
  CNCSparseRowColumn* row_ ;
  CNCSparseRowColumn* column_ ;
  double* diag_ ;
 
  Storage storage_ ;
  bool rows_are_stored_ ;
  bool columns_are_stored_ ;
  bool symmetric_storage_ ;
  bool symmetric_tag_ ;
 
  // SparseMatrix cannot be copied.
  CNC_Matrix(const CNC_Matrix& rhs) ;
  CNC_Matrix& operator=(const CNC_Matrix& rhs) ;
} ;
 
 
ARCANE_END_NAMESPACE
 
#endif