Real3x3.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Real3x3.h                                                   (C) 2000-2025 */
/*                                                                           */
/* Matrice 3x3 de 'Real'.                                                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_REAL3X3_H
#define ARCANE_UTILS_REAL3X3_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Real3.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
struct Real3x3POD
{
 public:
 
  Real3POD x;
  Real3POD y;
  Real3POD z;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT Real3x3
{
 public:

  constexpr ARCCORE_HOST_DEVICE Real3x3()
  : x(Real3::zero())
  , y(Real3::zero())
  , z(Real3::zero())
  {}

  constexpr ARCCORE_HOST_DEVICE Real3x3(Real3 ax, Real3 ay, Real3 az)
  : x(ax)
  , y(ay)
  , z(az)
  {}

  ARCANE_DEPRECATED_116 Real3x3(Real ax, Real ay, Real az, Real bx, Real by, Real bz, Real cx, Real cy, Real cz)
  : x(ax, bx, cx)
  , y(ay, by, cy)
  , z(az, bz, cz)
  {}

  Real3x3(const Real3x3& f) = default;
  constexpr ARCCORE_HOST_DEVICE explicit Real3x3(const Real3x3POD& f)
  : x(f.x)
  , y(f.y)
  , z(f.z)
  {}

  constexpr ARCCORE_HOST_DEVICE explicit Real3x3(Real v)
  {
    x = y = z = v;
  }

  constexpr ARCCORE_HOST_DEVICE explicit Real3x3(ConstArrayView<Real> av)
  : x(av[0], av[1], av[2])
  , y(av[3], av[4], av[5])
  , z(av[6], av[7], av[8])
  {}

  Real3x3& operator=(const Real3x3& f) = default;

  constexpr ARCCORE_HOST_DEVICE Real3x3& operator=(Real v)
  {
    x = y = z = v;
    return (*this);
  }
 
 public:
 
  Real3 x; 
  Real3 y; 
  Real3 z; 
 
 public:

  constexpr ARCCORE_HOST_DEVICE static Real3x3 null() { return Real3x3(); }

  constexpr ARCCORE_HOST_DEVICE static Real3x3 zero() { return Real3x3(); }

  constexpr ARCCORE_HOST_DEVICE static Real3x3 identity() { return Real3x3(Real3(1.0, 0.0, 0.0), Real3(0.0, 1.0, 0.0), Real3(0.0, 0.0, 1.0)); }

  constexpr ARCCORE_HOST_DEVICE static Real3x3 fromColumns(Real ax, Real ay, Real az, Real bx, Real by, Real bz, Real cx, Real cy, Real cz)
  {
    return Real3x3(Real3(ax, bx, cx), Real3(ay, by, cy), Real3(az, bz, cz));
  }

  constexpr ARCCORE_HOST_DEVICE static Real3x3 fromLines(Real ax, Real bx, Real cx, Real ay, Real by, Real cy, Real az, Real bz, Real cz)
  {
    return Real3x3(Real3(ax, bx, cx), Real3(ay, by, cy), Real3(az, bz, cz));
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE Real3x3 copy() const { return (*this); }

  constexpr ARCCORE_HOST_DEVICE Real3x3& reset()
  {
    *this = zero();
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& assign(Real3 ax, Real3 ay, Real3 az)
  {
    x = ax;
    y = ay;
    z = az;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& assign(Real3x3 f)
  {
    x = f.x;
    y = f.y;
    z = f.z;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE ArrayView<Real> view()
  {
    return { 9, &x.x };
  }

  constexpr ARCCORE_HOST_DEVICE ConstArrayView<Real> constView() const
  {
    return { 9, &x.x };
  }

  std::istream& assign(std::istream& i);
  std::ostream& print(std::ostream& o) const;
  std::ostream& printXyz(std::ostream& o) const;

  constexpr ARCCORE_HOST_DEVICE Real3x3& add(Real3x3 b)
  {
    x += b.x;
    y += b.y;
    z += b.z;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& sub(Real3x3 b)
  {
    x -= b.x;
    y -= b.y;
    z -= b.z;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& addSame(Real3 b)
  {
    x += b;
    y += b;
    z += b;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& subSame(Real3 b)
  {
    x -= b;
    y -= b;
    z -= b;
    return (*this);
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3& operator+=(Real3x3 b) { return add(b); }
  constexpr ARCCORE_HOST_DEVICE Real3x3& operator-=(Real3x3 b) { return sub(b); }
  constexpr ARCCORE_HOST_DEVICE void operator*=(Real b)
  {
    x *= b;
    y *= b;
    z *= b;
  }

  constexpr ARCCORE_HOST_DEVICE void operator/=(Real b)
  {
    x /= b;
    y /= b;
    z /= b;
  }

  constexpr ARCCORE_HOST_DEVICE Real3x3 operator+(Real3x3 b) const { return Real3x3(x + b.x, y + b.y, z + b.z); }
  constexpr ARCCORE_HOST_DEVICE Real3x3 operator-(Real3x3 b) const { return Real3x3(x - b.x, y - b.y, z - b.z); }
  constexpr ARCCORE_HOST_DEVICE Real3x3 operator-() const { return Real3x3(-x, -y, -z); }

  constexpr ARCCORE_HOST_DEVICE bool operator==(Real3x3 b) const
  {
    return x == b.x && y == b.y && z == b.z;
  }

  constexpr ARCCORE_HOST_DEVICE bool operator!=(Real3x3 b) const
  {
    return !operator==(b);
  }

  ARCCORE_HOST_DEVICE Real3 operator[](Integer i) const
  {
    ARCCORE_CHECK_AT(i, 3);
    return (&x)[i];
  }

  ARCCORE_HOST_DEVICE Real3 operator()(Integer i) const
  {
    ARCCORE_CHECK_AT(i, 3);
    return (&x)[i];
  }

  ARCCORE_HOST_DEVICE Real operator()(Integer i, Integer j) const
  {
    ARCCORE_CHECK_AT(i, 3);
    ARCCORE_CHECK_AT(j, 3);
    return (&x)[i][j];
  }

  ARCCORE_HOST_DEVICE Real3& operator[](Integer i)
  {
    ARCCORE_CHECK_AT(i, 3);
    return (&x)[i];
  }

  ARCCORE_HOST_DEVICE Real3& operator()(Integer i)
  {
    ARCCORE_CHECK_AT(i, 3);
    return (&x)[i];
  }

  ARCCORE_HOST_DEVICE Real& operator()(Integer i, Integer j)
  {
    ARCCORE_CHECK_AT(i, 3);
    ARCCORE_CHECK_AT(j, 3);
    return (&x)[i][j];
  }

  constexpr ARCCORE_HOST_DEVICE Real determinant() const
  {
    return (x.x * (y.y * z.z - y.z * z.y) + x.y * (y.z * z.x - y.x * z.z) + x.z * (y.x * z.y - y.y * z.x));
  }

  friend std::ostream& operator<<(std::ostream& o, Real3x3 t)
  {
    return t.printXyz(o);
  }

  friend std::istream& operator>>(std::istream& i, Real3x3& t)
  {
    return t.assign(i);
  }

  friend constexpr ARCCORE_HOST_DEVICE Real3x3 operator*(Real sca, Real3x3 vec)
  {
    return Real3x3(vec.x * sca, vec.y * sca, vec.z * sca);
  }

  friend constexpr ARCCORE_HOST_DEVICE Real3x3 operator*(Real3x3 vec, Real sca)
  {
    return Real3x3(vec.x * sca, vec.y * sca, vec.z * sca);
  }

  friend constexpr ARCCORE_HOST_DEVICE Real3x3 operator/(Real3x3 vec, Real sca)
  {
    return Real3x3(vec.x / sca, vec.y / sca, vec.z / sca);
  }

  friend constexpr ARCCORE_HOST_DEVICE bool operator<(Real3x3 v1, Real3x3 v2)
  {
    if (v1.x == v2.x) {
      if (v1.y == v2.y)
        return v1.z < v2.z;
      else
        return v1.y < v2.y;
    }
    return (v1.x < v2.x);
  }
 
 public:
 
  // TODO: rendre obsolète mi-2025: ARCANE_DEPRECATED_REASON("Y2024: Use math::isNearlyZero(const Real3x3&) instead")
  inline constexpr ARCCORE_HOST_DEVICE bool isNearlyZero() const;
 
 private:

  constexpr ARCCORE_HOST_DEVICE static bool _eq(Real a, Real b)
  {
    return TypeEqualT<Real>::isEqual(a, b);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace math
{
  inline constexpr ARCCORE_HOST_DEVICE bool isNearlyZero(const Real3x3& v)
  {
    return isNearlyZero(v.x) && isNearlyZero(v.y) && isNearlyZero(v.z);
  }
} // namespace math
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline constexpr ARCCORE_HOST_DEVICE bool Real3x3::
isNearlyZero() const
{
  return math::isNearlyZero(*this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif