Real2Proxy.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Real2Proxy.h                                                (C) 2000-2008 */
/*                                                                           */
/* Proxy of a 'Real2'.                                                       */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_REAL2PROXY_H
#define ARCANE_UTILS_REAL2PROXY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Real2.h"
#include "arcane/utils/BuiltInProxy.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_UTILS_EXPORT Real2Proxy
{
 public:

  Real2Proxy(Real2& value, const MemoryAccessInfo& info)
  : x(value.x, info)
  , y(value.y, info)
  , m_value(value)
  , m_info(info)
  {}

  Real2Proxy(const Real2Proxy& f)
  : x(f.x)
  , y(f.y)
  , m_value(f.m_value)
  , m_info(f.m_info)
  {}
  const Real2& operator=(Real2Proxy f)
  {
    x = f.x;
    y = f.y;
    return m_value;
  }
  const Real2& operator=(Real2 f)
  {
    x = f.x;
    y = f.y;
    return m_value;
  }

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

  Real2 copy() const { return m_value; }

  Real2Proxy& reset()
  {
    x = y = 0.;
    return (*this);
  }

  Real2Proxy& assign(Real ax, Real ay)
  {
    x = ax;
    y = ay;
    return (*this);
  }

  Real2Proxy& assign(Real2 f)
  {
    x = f.x;
    y = f.y;
    return (*this);
  }

  bool isNearlyZero() const
  {
    return math::isNearlyZero(x.getValue()) && math::isNearlyZero(y.getValue());
  }

  Real abs2() const
  {
    return x * x + y * y;
  }

  Real abs() const
  {
    return _sqrt(abs2());
  }

  istream& assign(istream& i);

  ostream& print(ostream& o) const;

  ostream& printXy(ostream& o) const;

  Real2Proxy& add(Real2 b)
  {
    x += b.x;
    y += b.y;
    return (*this);
  }

  Real2Proxy& sub(Real2 b)
  {
    x -= b.x;
    y -= b.y;
    return (*this);
  }

  Real2Proxy& mul(Real2 b)
  {
    x *= b.x;
    y *= b.y;
    return (*this);
  }

  Real2Proxy& div(Real2 b)
  {
    x /= b.x;
    y /= b.y;
    return (*this);
  }

  Real2Proxy& addSame(Real b)
  {
    x += b;
    y += b;
    return (*this);
  }

  Real2Proxy& subSame(Real b)
  {
    x -= b;
    y -= b;
    return (*this);
  }

  Real2Proxy& mulSame(Real b)
  {
    x *= b;
    y *= b;
    return (*this);
  }

  Real2Proxy& divSame(Real b)
  {
    x /= b;
    y /= b;
    return (*this);
  }

  Real2Proxy& operator+=(Real2 b) { return add(b); }

  Real2Proxy& operator-=(Real2 b) { return sub(b); }

  Real2Proxy& operator*=(Real2 b) { return mul(b); }

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

  Real2Proxy& operator/=(Real2 b) { return div(b); }

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

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

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

  Real2 operator-() const { return Real2(-x, -y); }

  Real2 operator*(Real2 b) const { return Real2(x * b.x, y * b.y); }

  Real2 operator/(Real2 b) const { return Real2(x / b.x, y / b.y); }

  Real2Proxy& normalize()
  {
    Real d = abs();
    if (!math::isZero(d))
      divSame(d);
    return (*this);
  }

  bool operator==(Real2 b) const
  {
    return _eq(x, b.x) && _eq(y, b.y);
  }

  bool operator!=(Real2 b) const
  {
    return !operator==(b);
  }
 
 public:
 
  Real2 getValue() const
  {
    m_info.setRead();
    return m_value;
  }
  Real2& getValueMutable()
  {
    m_info.setReadOrWrite();
    return m_value;
  }
 
 private:

  static bool _eq(Real a, Real b)
  {
    return math::isEqual(a, b);
  }

  static Real _sqrt(Real a)
  {
    return math::sqrt(a);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

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

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

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

inline bool
operator<(const Real2Proxy& v1, const Real2Proxy& v2)
{
  return v1.getValue() < v2.getValue();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline ostream&
operator<<(ostream& o, Real2Proxy t)
{
  return t.printXy(o);
}

inline istream&
operator>>(istream& i, Real2Proxy& t)
{
  return t.assign(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif