Real3x3Proxy.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Real3x3Proxy.h                                              (C) 2000-2008 */
/*                                                                           */
/* Proxy for a 'Real3x3'.                                                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_REAL3X3PROXY_H
#define ARCANE_UTILS_REAL3X3PROXY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Real3x3.h"
#include "arcane/utils/Real3Proxy.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_UTILS_EXPORT Real3x3Proxy
{
 public:

  Real3x3Proxy(Real3x3& value, const MemoryAccessInfo& info)
  : x(value.x, info)
  , y(value.y, info)
  , z(value.z, info)
  , m_value(value)
  , m_info(info)
  {}

  Real3x3Proxy(const Real3x3Proxy& f)
  : x(f.x)
  , y(f.y)
  , z(f.z)
  , m_value(f.m_value)
  , m_info(f.m_info)
  {}
  const Real3x3& operator=(const Real3x3Proxy f)
  {
    x = f.x;
    y = f.y;
    z = f.z;
    return m_value;
  }
  const Real3x3& operator=(Real3x3 f)
  {
    x = f.x;
    y = f.y;
    z = f.z;
    return m_value;
  }

  const Real3x3& operator=(Real v)
  {
    x = y = z = v;
    return m_value;
  }
  operator const Real3x3&() const
  {
    return getValue();
  }
  //operator Real3x3()
  //{
  //  return getValueMutable();
  //}
 
 public:
 
  Real3Proxy x; 
  Real3Proxy y; 
  Real3Proxy z; 
 
 private:
 
  Real3x3& m_value;
  MemoryAccessInfo m_info;
 
 public:

  Real3x3 copy() const { return m_value; }

  Real3x3Proxy& reset()
  {
    x.reset();
    y.reset();
    z.reset();
    return (*this);
  }

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

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

  bool isNearlyZero() const
  {
    return x.isNearlyZero() && y.isNearlyZero() && z.isNearlyZero();
  }

  std::istream& assign(std::istream& i);

  std::ostream& print(std::ostream& o) const;

  std::ostream& printXyz(std::ostream& o) const;

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

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

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

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

  Real3x3Proxy& mulSame(Real3 b)
  {
    x *= b;
    y *= b;
    z *= b;
    return (*this);
  }

  Real3x3Proxy& divSame(Real3 b)
  {
    x /= b;
    y /= b;
    z /= b;
    return (*this);
  }

  Real3x3Proxy& operator+=(Real3x3 b) { return add(b); }

  Real3x3Proxy& operator-=(Real3x3 b) { return sub(b); }

  void operator*=(Real b)
  {
    x *= b;
    y *= b;
    z *= b;
  }

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

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

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

  Real3x3 operator-() const { return Real3x3(-x, -y, -z); }
 
 public:
 
  const Real3x3& getValue() const
  {
    m_info.setRead();
    return m_value;
  }
  Real3x3& getValueMutable()
  {
    m_info.setReadOrWrite();
    return m_value;
  }
 
 private:

  static bool _eq(Real a, Real b)
  {
    return TypeEqualT<Real>::isEqual(a, b);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

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

inline std::istream&
operator>>(std::istream& i, Real3x3Proxy& t)
{
  return t.assign(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline bool
operator==(const Real3x3& a, const Real3x3Proxy& b)
{
  return a == b.getValue();
}
inline bool
operator==(const Real3x3Proxy& a, const Real3x3& b)
{
  return a.getValue() == b;
}
inline bool
operator==(const Real3x3Proxy& a, const Real3x3Proxy& b)
{
  return a.getValue() == b.getValue();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline bool
operator!=(const Real3x3& a, const Real3x3Proxy& b)
{
  return a != b.getValue();
}
inline bool
operator!=(const Real3x3Proxy& a, const Real3x3& b)
{
  return a.getValue() != b;
}
inline bool
operator!=(const Real3x3Proxy& a, const Real3x3Proxy& b)
{
  return a.getValue() != b.getValue();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline Real3x3
operator*(Real sca, Real3x3Proxy vec)
{
  return Real3x3(vec.x * sca, vec.y * sca, vec.z * sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline Real3x3
operator*(const Real3x3Proxy& vec, Real sca)
{
  return Real3x3(vec.x * sca, vec.y * sca, vec.z * sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline Real3x3
operator/(const Real3x3Proxy& vec, Real sca)
{
  return Real3x3(vec.x / sca, vec.y / sca, vec.z / sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline bool
operator<(Real3x3Proxy v1, Real3x3Proxy 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);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif