Changeset 1423 in Sophya


Ignore:
Timestamp:
Feb 23, 2001, 2:57:40 PM (25 years ago)
Author:
ansari
Message:

modif pour documentation - Reza 23/2/2001

Location:
trunk/SophyaLib/SkyMap
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/SkyMap/localmap.h

    r1419 r1423  
    186186////////////////////////////////////////////////////////////////
    187187// Surcharge d'operateurs A (+,-,*,/) (T) x
    188 /*! \ingroup LocalMap \fn operator+(const LocalMap<T>&,T)
     188/*! \ingroup SkyMap \fn operator+(const LocalMap<T>&,T)
    189189  \brief Operator LocalMap = LocalMap + constant */
    190190template <class T> inline LocalMap<T> operator + (const LocalMap<T>& a, T b)
    191191    {LocalMap<T> result; result.CloneOrShare(a); result.SetTemp(true);
    192192    result.Add(b); return result;}
    193 /*! \ingroup LocalMap \fn operator+(T,const LocalMap<T>&)
     193/*! \ingroup SkyMap \fn operator+(T,const LocalMap<T>&)
    194194  \brief Operator LocalMap = constant + LocalMap */
    195195template <class T> inline LocalMap<T> operator + (T b,const LocalMap<T>& a)
    … …  
    198198
    199199
    200 /*! \ingroup LocalMap\fn operator-(const LocalMap<T>&,T)
     200/*! \ingroup SkyMap\fn operator-(const LocalMap<T>&,T)
    201201  \brief Operator LocalMap = LocalMap - constant */
    202202template <class T> inline LocalMap<T> operator - (const LocalMap<T>& a, T b)
    … …  
    210210    result.Sub(b,true); return result;}
    211211
    212 /*! \ingroup LocalMap \fn operator*(const LocalMap<T>&,T)
     212/*! \ingroup SkyMap \fn operator*(const LocalMap<T>&,T)
    213213  \brief Operator LocalMap = LocalMap * constant */
    214214template <class T> inline LocalMap<T> operator * (const LocalMap<T>& a, T b)
    … …  
    216216    result.Mul(b); return result;}
    217217
    218 /*! \ingroup LocalMap \fn operator*(T,const LocalMap<T>&)
     218/*! \ingroup SkyMap \fn operator*(T,const LocalMap<T>&)
    219219  \brief Operator LocalMap = constant * LocalMap */
    220220template <class T> inline LocalMap<T> operator * (T b,const LocalMap<T>& a)
    … …  
    222222    result.Mul(b); return result;}
    223223
    224 /*! \ingroup LocalMap \fn operator/(const LocalMap<T>&,T)
     224/*! \ingroup SkyMap \fn operator/(const LocalMap<T>&,T)
    225225  \brief Operator LocalMap = LocalMap / constant */
    226226template <class T> inline LocalMap<T> operator / (const LocalMap<T>& a, T b)
    … …  
    228228    result.Div(b); return result;}
    229229
    230 /*! \ingroup LocalMap \fn operator/(T,const LocalMap<T>&)
     230/*! \ingroup SkyMap \fn operator/(T,const LocalMap<T>&)
    231231  \brief Operator LocalMap = constant / LocalMap  */
    232232template <class T> inline LocalMap<T> operator / (T b, const LocalMap<T>& a)
    … …  
    237237// Surcharge d'operateurs C = A (+,-) B
    238238
    239 /*! \ingroup LocalMap \fn operator+(const LocalMap<T>&,const LocalMap<T>&)
     239/*! \ingroup SkyMap \fn operator+(const LocalMap<T>&,const LocalMap<T>&)
    240240  \brief Operator LocalMap = LocalMap + LocalMap */
    241241template <class T>
    … …  
    246246    return result; }
    247247
    248 /*! \ingroup LocalMap \fn operator-(const LocalMap<T>&,const LocalMap<T>&)
     248/*! \ingroup SkyMap \fn operator-(const LocalMap<T>&,const LocalMap<T>&)
    249249  \brief Operator LocalMap = LocalMap - LocalMap */
    250250template <class T>

  • trunk/SophyaLib/SkyMap/spherehealpix.h

    r1419 r1423  
    209209////////////////////////////////////////////////////////////////
    210210// Surcharge d'operateurs A (+,-,*,/) (T) x
    211 /*! \ingroup SphereHEALPix \fn operator+(const SphereHEALPix<T>&,T)
     211/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,T)
    212212  \brief Operator SphereHEALPix = SphereHEALPix + constant */
    213213template <class T> inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a, T b)
    214214    {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
    215215    result.Add(b); return result;}
    216 /*! \ingroup SphereHEALPix \fn operator+(T,const SphereHEALPix<T>&)
     216/*! \ingroup SkyMap \fn operator+(T,const SphereHEALPix<T>&)
    217217  \brief Operator SphereHEALPix = constant + SphereHEALPix */
    218218template <class T> inline SphereHEALPix<T> operator + (T b,const SphereHEALPix<T>& a)
    … …  
    233233    result.Sub(b,true); return result;}
    234234
    235 /*! \ingroup SphereHEALPix \fn operator*(const SphereHEALPix<T>&,T)
     235/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,T)
    236236  \brief Operator SphereHEALPix = SphereHEALPix * constant */
    237237template <class T> inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a, T b)
    … …  
    239239    result.Mul(b); return result;}
    240240
    241 /*! \ingroup SphereHEALPix \fn operator*(T,const SphereHEALPix<T>&)
     241/*! \ingroup SkyMap \fn operator*(T,const SphereHEALPix<T>&)
    242242  \brief Operator SphereHEALPix = constant * SphereHEALPix */
    243243template <class T> inline SphereHEALPix<T> operator * (T b,const SphereHEALPix<T>& a)
    … …  
    245245    result.Mul(b); return result;}
    246246
    247 /*! \ingroup SphereHEALPix \fn operator/(const SphereHEALPix<T>&,T)
     247/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,T)
    248248  \brief Operator SphereHEALPix = SphereHEALPix / constant */
    249249template <class T> inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a, T b)
    … …  
    251251    result.Div(b); return result;}
    252252
    253 /*! \ingroup SphereHEALPix \fn operator/(T,const SphereHEALPix<T>&)
     253/*! \ingroup SkyMap \fn operator/(T,const SphereHEALPix<T>&)
    254254  \brief Operator SphereHEALPix = constant / SphereHEALPix  */
    255255template <class T> inline SphereHEALPix<T> operator / (T b, const SphereHEALPix<T>& a)
    … …  
    260260// Surcharge d'operateurs C = A (+,-) B
    261261
    262 /*! \ingroup SphereHEALPix \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
     262/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
    263263  \brief Operator SphereHEALPix = SphereHEALPix + SphereHEALPix */
    264264template <class T>
    … …  
    269269    return result; }
    270270
    271 /*! \ingroup SphereHEALPix \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
     271/*! \ingroup SkyMap \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
    272272  \brief Operator SphereHEALPix = SphereHEALPix - SphereHEALPix */
    273273template <class T>

  • trunk/SophyaLib/SkyMap/spherethetaphi.h

    r1419 r1423  
    263263////////////////////////////////////////////////////////////////
    264264// Surcharge d'operateurs A (+,-,*,/) (T) x
    265 /*! \ingroup SphereThetaPhi \fn operator+(const SphereThetaPhi<T>&,T)
     265/*! \ingroup SkyMap \fn operator+(const SphereThetaPhi<T>&,T)
    266266  \brief Operator SphereThetaPhi = SphereThetaPhi + constant */
    267267template <class T> inline SphereThetaPhi<T> operator + (const SphereThetaPhi<T>& a, T b)
    268268    {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
    269269    result.Add(b); return result;}
    270 /*! \ingroup SphereThetaPhi \fn operator+(T,const SphereThetaPhi<T>&)
     270/*! \ingroup SkyMap \fn operator+(T,const SphereThetaPhi<T>&)
    271271  \brief Operator SphereThetaPhi = constant + SphereThetaPhi */
    272272template <class T> inline SphereThetaPhi<T> operator + (T b,const SphereThetaPhi<T>& a)
    … …  
    287287    result.Sub(b,true); return result;}
    288288
    289 /*! \ingroup SphereThetaPhi \fn operator*(const SphereThetaPhi<T>&,T)
     289/*! \ingroup SkyMap \fn operator*(const SphereThetaPhi<T>&,T)
    290290  \brief Operator SphereThetaPhi = SphereThetaPhi * constant */
    291291template <class T> inline SphereThetaPhi<T> operator * (const SphereThetaPhi<T>& a, T b)
    … …  
    293293    result.Mul(b); return result;}
    294294
    295 /*! \ingroup SphereThetaPhi \fn operator*(T,const SphereThetaPhi<T>&)
     295/*! \ingroup SkyMap \fn operator*(T,const SphereThetaPhi<T>&)
    296296  \brief Operator SphereThetaPhi = constant * SphereThetaPhi */
    297297template <class T> inline SphereThetaPhi<T> operator * (T b,const SphereThetaPhi<T>& a)
    … …  
    299299    result.Mul(b); return result;}
    300300
    301 /*! \ingroup SphereThetaPhi \fn operator/(const SphereThetaPhi<T>&,T)
     301/*! \ingroup SkyMap \fn operator/(const SphereThetaPhi<T>&,T)
    302302  \brief Operator SphereThetaPhi = SphereThetaPhi / constant */
    303303template <class T> inline SphereThetaPhi<T> operator / (const SphereThetaPhi<T>& a, T b)
    … …  
    305305    result.Div(b); return result;}
    306306
    307 /*! \ingroup SphereThetaPhi \fn operator/(T,const SphereThetaPhi<T>&)
     307/*! \ingroup SkyMap \fn operator/(T,const SphereThetaPhi<T>&)
    308308  \brief Operator SphereThetaPhi = constant / SphereThetaPhi  */
    309309template <class T> inline SphereThetaPhi<T> operator / (T b, const SphereThetaPhi<T>& a)
    … …  
    314314// Surcharge d'operateurs C = A (+,-) B
    315315
    316 /*! \ingroup SphereThetaPhi \fn operator+(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
     316/*! \ingroup SkyMap \fn operator+(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
    317317  \brief Operator SphereThetaPhi = SphereThetaPhi + SphereThetaPhi */
    318318template <class T>
    … …  
    323323    return result; }
    324324
    325 /*! \ingroup SphereThetaPhi \fn operator-(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
     325/*! \ingroup SkyMap \fn operator-(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
    326326  \brief Operator SphereThetaPhi = SphereThetaPhi - SphereThetaPhi */
    327327template <class T>
Note: See TracChangeset for help on using the changeset viewer.