ValueTypeInterface.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ValueTypeInterface.h                                        (C) 2000-2026 */
/*                                                                           */
/* Support for various value types.                                          */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_VALUETYPEINTERFACE_H
#define ARCCORE_ALINA_VALUETYPEINTERFACE_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 <type_traits>
#include <complex>
 
namespace Arcane::Alina::math
{

template <class T, class Enable = void>
struct scalar_of
{
  typedef T type;
};

template <class T, class Enable = void>
struct rhs_of
{
  typedef T type;
};

template <class T, class Enable = void>
struct element_of
{
  typedef T type;
};

template <class T, class S, class Enable = void>
struct replace_scalar
{
  typedef S type;
};

template <class T, class Enable = void>
struct is_static_matrix : std::false_type
{};

template <class T, class Enable = void>
struct static_rows : std::integral_constant<int, 1>
{};

template <class T, class Enable = void>
struct static_cols : std::integral_constant<int, 1>
{};


template <typename ValueType, class Enable = void>
struct adjoint_impl
{
  typedef ValueType return_type;
 
  static ValueType get(ValueType x)
  {
    return x;
  }
};


template <typename ValueType, class Enable = void>
struct inner_product_impl
{
  typedef ValueType return_type;
 
  static return_type get(ValueType x, ValueType y)
  {
    return x * y;
  }
};


template <typename ValueType, class Enable = void>
struct norm_impl
{
  static typename scalar_of<ValueType>::type get(ValueType x)
  {
    return std::abs(x);
  }
};


template <typename ValueType, class Enable = void>
struct zero_impl
{
  static ValueType get()
  {
    return static_cast<ValueType>(0);
  }
};


template <typename ValueType, class Enable = void>
struct is_zero_impl
{
  static bool get(const ValueType& x)
  {
    return x == zero_impl<ValueType>::get();
  }
};


template <typename ValueType, class Enable = void>
struct identity_impl
{
  static ValueType get()
  {
    return static_cast<ValueType>(1);
  }
};


template <typename ValueType, class Enable = void>
struct constant_impl
{
  static ValueType get(typename scalar_of<ValueType>::type c)
  {
    return static_cast<ValueType>(c);
  }
};


template <typename ValueType, class Enable = void>
struct inverse_impl
{
  static ValueType get(const ValueType& x)
  {
    return identity_impl<ValueType>::get() / x;
  }
};

template <typename ValueType>
typename adjoint_impl<ValueType>::return_type
adjoint(ValueType x)
{
  return adjoint_impl<ValueType>::get(x);
}

template <typename ValueType>
typename inner_product_impl<ValueType>::return_type
inner_product(ValueType x, ValueType y)
{
  return inner_product_impl<ValueType>::get(x, y);
}

template <typename ValueType>
typename scalar_of<ValueType>::type norm(const ValueType& a)
{
  return norm_impl<ValueType>::get(a);
}

template <typename ValueType>
ValueType zero()
{
  return zero_impl<ValueType>::get();
}

template <typename ValueType>
bool is_zero(const ValueType& x)
{
  return is_zero_impl<ValueType>::get(x);
}

template <typename ValueType>
ValueType identity()
{
  return identity_impl<ValueType>::get();
}

template <typename ValueType>
ValueType constant(typename scalar_of<ValueType>::type c)
{
  return constant_impl<ValueType>::get(c);
}

template <typename ValueType>
ValueType inverse(const ValueType& x)
{
  return inverse_impl<ValueType>::get(x);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina::math
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif