BackendInterface.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* BackendInterface.h                                          (C) 2000-2026 */
/*                                                                           */
/* Backend interface required for AMG.                        .              */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_BACKENDINTERFACE_H
#define ARCCORE_ALINA_BACKENDINTERFACE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * This file is based on the work on AMGCL library (version march 2026)
 * which can be found at https://github.com/ddemidov/amgcl.
 *
 * Copyright (c) 2012-2022 Denis Demidov <dennis.demidov@gmail.com>
 * SPDX-License-Identifier: MIT
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include <cmath>
 
#include <type_traits>
 
#include "arccore/alina/ValueTypeInterface.h"
#include "arccore/alina/AlinaUtils.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Alina::backend
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/




template <class SBackend, class PBackend>
struct backends_compatible : std::is_same<SBackend, PBackend>
{};

template <class T, class Enable = void>
struct value_type
{
  typedef typename T::value_type type;
};

template <class T, class Enable = void>
struct col_type
{
  typedef typename T::col_type type;
};

template <class T, class Enable = void>
struct ptr_type
{
  typedef typename T::ptr_type type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct rows_impl
{
  static size_t get(const Matrix& A)
  {
    return A.rows();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct cols_impl
{
  static size_t get(const Matrix& A)
  {
    return A.cols();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class T, class Enable = void>
struct bytes_impl
{
 
  // Use bytes() method when available.
  template <class U>
  static auto get_impl(const U& t, int) -> decltype(t.bytes())
  {
    return t.bytes();
  }
 
  // Fallback to zero.
  template <class U>
  static size_t get_impl(const U&, ...)
  {
    return 0;
  }
 
  static size_t get(const T& t)
  {
    return get_impl(t, 0);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class Matrix, class Enable = void>
struct ptr_data_impl
{
  typedef typename Matrix::PTR_DATA_NOT_IMPLEMENTED type;
};
 
template <class Matrix, class Enable = void>
struct col_data_impl
{
  typedef typename Matrix::COL_DATA_NOT_IMPLEMENTED type;
};
 
template <class Matrix, class Enable = void>
struct val_data_impl
{
  typedef typename Matrix::VAL_DATA_NOT_IMPLEMENTED type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct nonzeros_impl
{
  static size_t get(const Matrix& A)
  {
    return A.nonzeros();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct row_nonzeros_impl
{
  typedef typename Matrix::ROW_NONZEROS_NOT_IMPLEMENTED type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct row_iterator
{
  typedef typename Matrix::row_iterator type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Enable = void>
struct row_begin_impl
{
  static typename row_iterator<Matrix>::type
  get(const Matrix& A, size_t row)
  {
    return A.row_begin(row);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Alpha, class Matrix, class Vector1, class Beta, class Vector2, class Enable = void>
struct spmv_impl
{
  typedef typename Matrix::SPMV_NOT_IMPLEMENTED type;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Vector1, class Vector2, class Vector3, class Enable = void>
struct residual_impl
{
  typedef typename Matrix::RESIDUAL_NOT_IMPLEMENTED type;
};

template <class Vector, class Enable = void>
struct clear_impl
{
  typedef typename Vector::CLEAR_NOT_IMPLEMENTED type;
};

template <class Vector1, class Vector2, class Enable = void>
struct copy_impl
{
  typedef typename Vector1::COPY_NOT_IMPLEMENTED type;
};

template <class Vector1, class Vector2, class Enable = void>
struct inner_product_impl
{
  typedef typename Vector1::INNER_PRODUCT_NOT_IMPLEMENTED type;
};

template <class A, class Vector1, class B, class Vector2, class Enable = void>
struct axpby_impl
{
  typedef typename Vector1::AXPBY_NOT_IMPLEMENTED type;
};

template <class A, class Vector1, class B, class Vector2, class C, class Vector3, class Enable = void>
struct axpbypcz_impl
{
  typedef typename Vector1::AXPBYPCZ_NOT_IMPLEMENTED type;
};

template <class Alpha, class Vector1, class Vector2, class Beta, class Vector3, class Enable = void>
struct vmul_impl
{
  typedef typename Vector1::VMUL_NOT_IMPLEMENTED type;
};

template <class MatrixValue, class Vector, bool IsConst, class Enable = void>
struct reinterpret_as_rhs_impl
{
  typedef typename MatrixValue::REINTERPRET_AS_RHS_NOT_IMPLEMENTED type;
};

 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Matrix>
size_t nbRow(const Matrix& matrix)
{
  return rows_impl<Matrix>::get(matrix);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Matrix>
size_t nbColumn(const Matrix& matrix)
{
  return cols_impl<Matrix>::get(matrix);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class T>
size_t bytes(const T& t)
{
  return bytes_impl<T>::get(t);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class Matrix>
typename ptr_data_impl<Matrix>::type
ptr_data(const Matrix& matrix)
{
  return ptr_data_impl<Matrix>::get(matrix);
}
 
template <class Matrix>
typename col_data_impl<Matrix>::type
col_data(const Matrix& matrix)
{
  return col_data_impl<Matrix>::get(matrix);
}
 
template <class Matrix>
typename val_data_impl<Matrix>::type
val_data(const Matrix& matrix)
{
  return val_data_impl<Matrix>::get(matrix);
}

template <class Matrix>
size_t nonzeros(const Matrix& matrix)
{
  return nonzeros_impl<Matrix>::get(matrix);
}

template <class Matrix>
typename row_iterator<Matrix>::type
row_begin(const Matrix& matrix, size_t row)
{
  return row_begin_impl<Matrix>::get(matrix, row);
}

template <class Matrix>
size_t row_nonzeros(const Matrix& A, size_t row)
{
  return row_nonzeros_impl<Matrix>::get(A, row);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Alpha, class Matrix, class Vector1, class Beta, class Vector2>
void spmv(Alpha alpha, const Matrix& A, const Vector1& x,
          Beta beta, Vector2& y)
{
  ARCCORE_ALINA_TIC("spmv");
  spmv_impl<Alpha, Matrix, Vector1, Beta, Vector2>::apply(alpha, A, x, beta, y);
  ARCCORE_ALINA_TOC("spmv");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Matrix, class Vector1, class Vector2, class Vector3>
void residual(const Vector1& rhs, const Matrix& A, const Vector2& x, Vector3& r)
{
  ARCCORE_ALINA_TIC("residual");
  residual_impl<Matrix, Vector1, Vector2, Vector3>::apply(rhs, A, x, r);
  ARCCORE_ALINA_TOC("residual");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Vector>
void clear(Vector& x)
{
  ARCCORE_ALINA_TIC("clear");
  clear_impl<Vector>::apply(x);
  ARCCORE_ALINA_TOC("clear");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Vector1, class Vector2>
void copy(const Vector1& x, Vector2& y)
{
  ARCCORE_ALINA_TIC("copy");
  copy_impl<Vector1, Vector2>::apply(x, y);
  ARCCORE_ALINA_TOC("copy");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Vector1, class Vector2>
typename math::inner_product_impl<typename value_type<Vector1>::type>::return_type
inner_product(const Vector1& x, const Vector2& y)
{
  typedef typename math::inner_product_impl<
  typename value_type<Vector1>::type>::return_type result_type;
 
  ARCCORE_ALINA_TIC("inner_product");
  result_type p = inner_product_impl<Vector1, Vector2>::get(x, y);
  ARCCORE_ALINA_TOC("inner_product");
 
  return p;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class A, class Vector1, class B, class Vector2>
void axpby(A a, Vector1 const& x, B b, Vector2& y)
{
  ARCCORE_ALINA_TIC("axpby");
  axpby_impl<A, Vector1, B, Vector2>::apply(a, x, b, y);
  ARCCORE_ALINA_TOC("axpby");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class A, class Vector1, class B, class Vector2, class C, class Vector3>
void axpbypcz(A a, Vector1 const& x, B b, Vector2 const& y, C c, Vector3& z)
{
  ARCCORE_ALINA_TIC("axpbypcz");
  axpbypcz_impl<A, Vector1, B, Vector2, C, Vector3>::apply(a, x, b, y, c, z);
  ARCCORE_ALINA_TOC("axpbypcz");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Alpha, class Vector1, class Vector2, class Beta, class Vector3>
void vmul(Alpha alpha, const Vector1& x, const Vector2& y, Beta beta, Vector3& z)
{
  ARCCORE_ALINA_TIC("vmul");
  vmul_impl<Alpha, Vector1, Vector2, Beta, Vector3>::apply(alpha, x, y, beta, z);
  ARCCORE_ALINA_TOC("vmul");
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class MatrixValue, class Vector>
typename reinterpret_as_rhs_impl<MatrixValue,
                                 typename std::decay<Vector>::type,
                                 std::is_const<typename std::remove_reference<Vector>::type>::value>::return_type
reinterpret_as_rhs(Vector&& x)
{
  return reinterpret_as_rhs_impl<MatrixValue,
                                 typename std::decay<Vector>::type,
                                 std::is_const<typename std::remove_reference<Vector>::type>::value>::get(std::forward<Vector>(x));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Backend, template <class> class Relaxation, class Enable = void>
struct relaxation_is_supported : std::true_type
{};

template <class Backend, template <class> class Coarsening, class Enable = void>
struct coarsening_is_supported : std::true_type
{};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Coefs, class Vecs, class Coef, class Vec>
void lin_comb(size_t n, const Coefs& c, const Vecs& v, const Coef& alpha, Vec& y)
{
  axpby(c[0], *v[0], alpha, y);
  size_t i = 1;
  for (; i + 1 < n; i += 2)
    axpbypcz(c[i], *v[i], c[i + 1], *v[i + 1], math::identity<Coef>(), y);
 
  for (; i < n; ++i)
    axpby(c[i], *v[i], math::identity<Coef>(), y);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina::backend
 
namespace Arcane::Alina::detail
{
 
// Backend with scalar value_type of highest precision.
template <class B>
struct common_scalar_backend<B, B, typename std::enable_if<math::static_rows<typename B::value_type>::value == 1>::type>
{
  typedef B type;
};
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif