Changeset 1419 in Sophya for trunk/SophyaLib/SkyMap/spherehealpix.h

Timestamp:

Feb 23, 2001, 12:26:48 PM (25 years ago)

Author:

lemeur

Message:

surcharge d'operateurs =, +=, *= etc...

File:

• trunk/SophyaLib/SkyMap/spherehealpix.h (modified) (2 diffs)

trunk/SophyaLib/SkyMap/spherehealpix.h

@@ -127 +127 @@
 
 
+
+ 
+
+
+
+// Operations diverses  = , +=, ...
+
+
+SphereHEALPix<T>& Set(const SphereHEALPix<T>& a);
 inline  SphereHEALPix<T>& operator = (const SphereHEALPix<T>& a) 
                                                         {return Set(a);}
 
+// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
+
+  //! Fill SphereHEALPix with all elements equal to \b x
+virtual SphereHEALPix<T>& SetT(T a); 
+inline  SphereHEALPix<T>& operator = (T a) {return SetT(a);}
+
+//! Add \b x to all elements
+virtual SphereHEALPix<T>& Add(T a); 
+inline  SphereHEALPix<T>&  operator += (T x)  { return Add(x); }
+//! Substract \b x to all elements
+virtual SphereHEALPix<T>& Sub(T a); 
+inline   SphereHEALPix<T>&  operator -= (T x)  { return Sub(x); }
+//! Multiply all elements by \b x
+virtual SphereHEALPix<T>& Mul(T a); 
+inline  SphereHEALPix<T>&  operator *= (T x)  { return Mul(x); }
+//! Divide all elements by \b x
+virtual SphereHEALPix<T>& Div(T a); 
+inline  SphereHEALPix<T>&  operator /= (T x)  { return Div(x); }
+
+// A += -=  (ajoute, soustrait element par element les deux spheres )
+  //! Operator SphereHEALPix += SphereHEALPix
+  virtual SphereHEALPix<T>&  AddElt(const SphereHEALPix<T>& a);
+  inline  SphereHEALPix<T>&  operator += (const SphereHEALPix<T>& a)  { return AddElt(a); }
+
+
+
+  virtual SphereHEALPix<T>&  SubElt(const SphereHEALPix<T>& a);
+  //! Operator SphereHEALPix -= SphereHEALPix
+  inline  SphereHEALPix<T>&  operator -= (const SphereHEALPix<T>& a)  { return SubElt(a); }
+// Multiplication, division element par element les deux SphereHEALPix 
+  virtual SphereHEALPix<T>&  MulElt(const SphereHEALPix<T>& a);
+  inline  SphereHEALPix<T>&  operator *= (const SphereHEALPix<T>& a)  { return MulElt(a); }
+
+
  void CloneOrShare(const SphereHEALPix<T>& a);
- SphereHEALPix<T>& Set(const SphereHEALPix<T>& a);
+ void Share(const SphereHEALPix<T>& a);
  SphereHEALPix<T>& CopyElt(const SphereHEALPix<T>& a);
 
@@ -164 +207 @@
 };
 
-
+////////////////////////////////////////////////////////////////
+// Surcharge d'operateurs A (+,-,*,/) (T) x
+/*! \ingroup SphereHEALPix \fn operator+(const SphereHEALPix<T>&,T)
+  \brief Operator SphereHEALPix = SphereHEALPix + constant */
+template <class T> inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a, T b)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Add(b); return result;}
+/*! \ingroup SphereHEALPix \fn operator+(T,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = constant + SphereHEALPix */
+template <class T> inline SphereHEALPix<T> operator + (T b,const SphereHEALPix<T>& a)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Add(b); return result;}
+
+
+/*! \ingroup SphereHEALPix\fn operator-(const SphereHEALPix<T>&,T)
+  \brief Operator SphereHEALPix = SphereHEALPix - constant */
+template <class T> inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a, T b)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Sub(b); return result;}
+
+/*! \ingroup  \fn operator-(T,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = constant - SphereHEALPix */
+template <class T> inline SphereHEALPix<T> operator - (T b,const SphereHEALPix<T>& a)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Sub(b,true); return result;}
+
+/*! \ingroup SphereHEALPix \fn operator*(const SphereHEALPix<T>&,T)
+  \brief Operator SphereHEALPix = SphereHEALPix * constant */
+template <class T> inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a, T b)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Mul(b); return result;}
+
+/*! \ingroup SphereHEALPix \fn operator*(T,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = constant * SphereHEALPix */
+template <class T> inline SphereHEALPix<T> operator * (T b,const SphereHEALPix<T>& a)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Mul(b); return result;}
+
+/*! \ingroup SphereHEALPix \fn operator/(const SphereHEALPix<T>&,T)
+  \brief Operator SphereHEALPix = SphereHEALPix / constant */
+template <class T> inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a, T b)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Div(b); return result;}
+
+/*! \ingroup SphereHEALPix \fn operator/(T,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = constant / SphereHEALPix  */
+template <class T> inline SphereHEALPix<T> operator / (T b, const SphereHEALPix<T>& a)
+    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Div(b, true); return result;}
+
+////////////////////////////////////////////////////////////////
+// Surcharge d'operateurs C = A (+,-) B
+
+/*! \ingroup SphereHEALPix \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = SphereHEALPix + SphereHEALPix */
+template <class T>
+inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
+    { SphereHEALPix<T> result; result.SetTemp(true); 
+    if (b.IsTemp())  { result.Share(b); result.AddElt(a); }
+    else { result.CloneOrShare(a); result.AddElt(b); }
+    return result; }
+
+/*! \ingroup SphereHEALPix \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
+  \brief Operator SphereHEALPix = SphereHEALPix - SphereHEALPix */
+template <class T>
+inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
+    { SphereHEALPix<T> result; result.SetTemp(true); 
+    if (b.IsTemp())  { result.Share(b); result.SubElt(a, true); }
+    else { result.CloneOrShare(a); result.SubElt(b); }
+    return result; }
 
 } // Fin du namespace