Real2Proxy.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 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 d'un 'Real2'.                                                       */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_REAL2PROXY_H
#define ARCANE_UTILS_REAL2PROXY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Real2.h"
#include "arcane/utils/BuiltInProxy.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif