AlephCudaMatrix.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 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_
 
namespace Arcane
{
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);
};
 
} // namespace Arcane
 
#endif