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

Timestamp:

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

Author:

lemeur

Message:

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

File:

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

trunk/SophyaLib/SkyMap/spherethetaphi.h

@@ -182 +182 @@
 void print(ostream& os) const;
 
+
+
+// Operations diverses  = , +=, ...
+
+
+SphereThetaPhi<T>& Set(const SphereThetaPhi<T>& a);
+inline  SphereThetaPhi<T>& operator = (const SphereThetaPhi<T>& a) 
+                                                        {return Set(a);}
+
+// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
+
+  //! Fill SphereThetaPhi with all elements equal to \b x
+virtual SphereThetaPhi<T>& SetT(T a); 
+inline  SphereThetaPhi<T>& operator = (T a) {return SetT(a);}
+
+//! Add \b x to all elements
+virtual SphereThetaPhi<T>& Add(T a); 
+inline  SphereThetaPhi<T>&  operator += (T x)  { return Add(x); }
+//! Substract \b x to all elements
+virtual SphereThetaPhi<T>& Sub(T a); 
+inline   SphereThetaPhi<T>&  operator -= (T x)  { return Sub(x); }
+//! Multiply all elements by \b x
+virtual SphereThetaPhi<T>& Mul(T a); 
+inline  SphereThetaPhi<T>&  operator *= (T x)  { return Mul(x); }
+//! Divide all elements by \b x
+virtual SphereThetaPhi<T>& Div(T a); 
+inline  SphereThetaPhi<T>&  operator /= (T x)  { return Div(x); }
+
+// A += -=  (ajoute, soustrait element par element les deux spheres )
+  //! Operator SphereThetaPhi += SphereThetaPhi
+  virtual SphereThetaPhi<T>&  AddElt(const SphereThetaPhi<T>& a);
+  inline  SphereThetaPhi<T>&  operator += (const SphereThetaPhi<T>& a)  { return AddElt(a); }
+
+
+
+  virtual SphereThetaPhi<T>&  SubElt(const SphereThetaPhi<T>& a);
+  //! Operator SphereThetaPhi -= SphereThetaPhi
+  inline  SphereThetaPhi<T>&  operator -= (const SphereThetaPhi<T>& a)  { return SubElt(a); }
+// Multiplication, division element par element les deux SphereThetaPhi 
+  virtual SphereThetaPhi<T>&  MulElt(const SphereThetaPhi<T>& a);
+  inline  SphereThetaPhi<T>&  operator *= (const SphereThetaPhi<T>& a)  { return MulElt(a); }
+
+
   void CloneOrShare(const SphereThetaPhi<T>& a);
-
-  SphereThetaPhi<T>& Set(const SphereThetaPhi<T>& a);
+  void Share(const SphereThetaPhi<T>& a);
+
   SphereThetaPhi<T>& CopyElt(const SphereThetaPhi<T>& a);
 
-  inline  SphereThetaPhi<T>& operator = (const SphereThetaPhi<T>& a) 
-                                                       {return Set(a);}
+
+
+
+
 
  // friend declaration for classes which handle persistence and FITS IO
@@ -216 +261 @@
 };
 
+////////////////////////////////////////////////////////////////
+// Surcharge d'operateurs A (+,-,*,/) (T) x
+/*! \ingroup SphereThetaPhi \fn operator+(const SphereThetaPhi<T>&,T)
+  \brief Operator SphereThetaPhi = SphereThetaPhi + constant */
+template <class T> inline SphereThetaPhi<T> operator + (const SphereThetaPhi<T>& a, T b)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Add(b); return result;}
+/*! \ingroup SphereThetaPhi \fn operator+(T,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = constant + SphereThetaPhi */
+template <class T> inline SphereThetaPhi<T> operator + (T b,const SphereThetaPhi<T>& a)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Add(b); return result;}
+
+
+/*! \ingroup SphereThetaPhi\fn operator-(const SphereThetaPhi<T>&,T)
+  \brief Operator SphereThetaPhi = SphereThetaPhi - constant */
+template <class T> inline SphereThetaPhi<T> operator - (const SphereThetaPhi<T>& a, T b)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Sub(b); return result;}
+
+/*! \ingroup  \fn operator-(T,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = constant - SphereThetaPhi */
+template <class T> inline SphereThetaPhi<T> operator - (T b,const SphereThetaPhi<T>& a)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Sub(b,true); return result;}
+
+/*! \ingroup SphereThetaPhi \fn operator*(const SphereThetaPhi<T>&,T)
+  \brief Operator SphereThetaPhi = SphereThetaPhi * constant */
+template <class T> inline SphereThetaPhi<T> operator * (const SphereThetaPhi<T>& a, T b)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Mul(b); return result;}
+
+/*! \ingroup SphereThetaPhi \fn operator*(T,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = constant * SphereThetaPhi */
+template <class T> inline SphereThetaPhi<T> operator * (T b,const SphereThetaPhi<T>& a)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Mul(b); return result;}
+
+/*! \ingroup SphereThetaPhi \fn operator/(const SphereThetaPhi<T>&,T)
+  \brief Operator SphereThetaPhi = SphereThetaPhi / constant */
+template <class T> inline SphereThetaPhi<T> operator / (const SphereThetaPhi<T>& a, T b)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Div(b); return result;}
+
+/*! \ingroup SphereThetaPhi \fn operator/(T,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = constant / SphereThetaPhi  */
+template <class T> inline SphereThetaPhi<T> operator / (T b, const SphereThetaPhi<T>& a)
+    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true); 
+    result.Div(b, true); return result;}
+
+////////////////////////////////////////////////////////////////
+// Surcharge d'operateurs C = A (+,-) B
+
+/*! \ingroup SphereThetaPhi \fn operator+(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = SphereThetaPhi + SphereThetaPhi */
+template <class T>
+inline SphereThetaPhi<T> operator + (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
+    { SphereThetaPhi<T> result; result.SetTemp(true); 
+    if (b.IsTemp())  { result.Share(b); result.AddElt(a); }
+    else { result.CloneOrShare(a); result.AddElt(b); }
+    return result; }
+
+/*! \ingroup SphereThetaPhi \fn operator-(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
+  \brief Operator SphereThetaPhi = SphereThetaPhi - SphereThetaPhi */
+template <class T>
+inline SphereThetaPhi<T> operator - (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
+    { SphereThetaPhi<T> result; result.SetTemp(true); 
+    if (b.IsTemp())  { result.Share(b); result.SubElt(a, true); }
+    else { result.CloneOrShare(a); result.SubElt(b); }
+    return result; }