ValueTypeEigen.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ValueTypeEigen.h                                            (C) 2000-2026 */
/*                                                                           */
/* Enable statically sized eigen matrices as value types.                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_VALUETYPEEIGEN_H
#define ARCCORE_ALINA_VALUETYPEEIGEN_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 <Eigen/Dense>
 
#include "arccore/alina/BuiltinBackend.h"
#include "arccore/alina/ValueTypeInterface.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Alina::backend
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename T, int N, int M>
struct is_builtin_vector<std::vector<Eigen::Matrix<T, N, M>>> : std::true_type
{};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina::backend
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Alina::math
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class T, int N, int M>
struct scalar_of<Eigen::Matrix<T, N, M>>
{
  typedef typename math::scalar_of<T>::type type;
};

template <class T, int N, int M, class S>
struct replace_scalar<Eigen::Matrix<T, N, M>, S>
{
  typedef Eigen::Matrix<S, N, M> type;
};

template <class T, int N>
struct rhs_of<Eigen::Matrix<T, N, N>>
{
  typedef Eigen::Matrix<T, N, 1> type;
};

template <class T, int N, int M>
struct element_of<Eigen::Matrix<T, N, M>>
{
  typedef T type;
};

template <class T, int N, int M>
struct is_static_matrix<Eigen::Matrix<T, N, M>> : std::true_type
{};

template <class T, int N, int M>
struct static_rows<Eigen::Matrix<T, N, M>> : std::integral_constant<int, N>
{};

template <class T, int N, int M>
struct static_cols<Eigen::Matrix<T, N, M>> : std::integral_constant<int, M>
{};

template <typename T, int N, int M>
struct adjoint_impl<Eigen::Matrix<T, N, M>>
{
  typedef typename Eigen::Matrix<T, N, M>::AdjointReturnType return_type;
 
  static return_type get(const Eigen::Matrix<T, N, M>& x)
  {
    return x.adjoint();
  }
};

template <class T, int N>
struct inner_product_impl<Eigen::Matrix<T, N, 1>>
{
  typedef T return_type;
  static T get(const Eigen::Matrix<T, N, 1>& x, const Eigen::Matrix<T, N, 1>& y)
  {
    return x.adjoint() * y;
  }
};

template <class T, int N, int M>
struct inner_product_impl<Eigen::Matrix<T, N, M>>
{
  typedef Eigen::Matrix<T, M, M> return_type;
 
  static return_type get(const Eigen::Matrix<T, N, M>& x, const Eigen::Matrix<T, N, M>& y)
  {
    return x.adjoint() * y;
  }
};

template <typename T, int N, int M>
struct norm_impl<Eigen::Matrix<T, N, M>>
{
  static typename math::scalar_of<T>::type get(const Eigen::Matrix<T, N, M>& x)
  {
    return x.norm();
  }
};

template <typename T, int N, int M>
struct zero_impl<Eigen::Matrix<T, N, M>>
{
  static Eigen::Matrix<T, N, M> get()
  {
    return Eigen::Matrix<T, N, M>::Zero();
  }
};

template <typename T, int N, int M>
struct is_zero_impl<Eigen::Matrix<T, N, M>>
{
  static bool get(const Eigen::Matrix<T, N, M>& x)
  {
    return x.isZero();
  }
};

template <typename T, int N>
struct identity_impl<Eigen::Matrix<T, N, N>>
{
  static Eigen::Matrix<T, N, N> get()
  {
    return Eigen::Matrix<T, N, N>::Identity();
  }
};

template <typename T, int N, int M>
struct constant_impl<Eigen::Matrix<T, N, M>>
{
  static Eigen::Matrix<T, N, M> get(T c)
  {
    return Eigen::Matrix<T, N, M>::Constant(c);
  }
};

template <typename T, int N>
struct inverse_impl<Eigen::Matrix<T, N, N>>
{
  static Eigen::Matrix<T, N, N> get(const Eigen::Matrix<T, N, N>& x)
  {
    return x.inverse();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina::math
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Eigen
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class A, class B>
bool operator<(const MatrixBase<A>& a, const MatrixBase<B>& b)
{
  return a.trace() < b.trace();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Eigen
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif