Index: trunk/SophyaLib/TArray/matharr.cc
===================================================================
--- trunk/SophyaLib/TArray/matharr.cc	(revision 1173)
+++ trunk/SophyaLib/TArray/matharr.cc	(revision 1226)
@@ -148,16 +148,5 @@
   mean /= dsz;
   sig = sig/dsz - mean*mean;
-#if !defined(__GNUG__) && !defined (__MWERKS__)
   if (sig >= 0.) sig = sqrt(sig);
-#else
-#if defined (__MWERKS__)
-  //	le std pour que CW comprenne que sqrt(double) vient de math.h!
-  if (sig >= 0.) sig = std::sqrt(sig);
-#else
-  // va comprendre pourquoi g++ veut ca pour faire la generation
-  // de template !!!! 
-  if (sig >= 0.) sig = _Sqrt_(sig);
-#endif
-#endif
   return(mean);
 }
Index: trunk/SophyaLib/TArray/matharr.h
===================================================================
--- trunk/SophyaLib/TArray/matharr.h	(revision 1173)
+++ trunk/SophyaLib/TArray/matharr.h	(revision 1226)
@@ -30,29 +30,27 @@
 //  Calcul de fonctions usuelles 
 
-  // #if !defined(OS_LINUX) && !defined (__KCC__)
-#if !defined(__GNUG__)
 // see below for g++   
-/*! \ingroup TArray \fn fabs(const TArray<T>& a)
+/*! \ingroup TArray \fn Fabs(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> fabs(const TArray<T>& a)
+inline TArray<T> Fabs(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, fabs) ); }
 
-/*! \ingroup TArray \fn sqrt(const TArray<T>& a)
+/*! \ingroup TArray \fn Sqrt(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> sqrt(const TArray<T>& a)
+inline TArray<T> Sqrt(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, sqrt) ); }
 
-/*! \ingroup TArray \fn sin(const TArray<T>& a)
+/*! \ingroup TArray \fn Sin(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> sin(const TArray<T>& a)
+inline TArray<T> Sin(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, sin) ); }
 
-/*! \ingroup TArray \fn cos(const TArray<T>& a)
+/*! \ingroup TArray \fn Cos(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> cos(const TArray<T>& a)
+inline TArray<T> Cos(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, cos) ); }
 
@@ -60,48 +58,43 @@
   \brief computation on TArray */
 template <class T>
-inline TArray<T> tan(const TArray<T>& a)
+inline TArray<T> Tan(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, tan) ); }
 
-/*! \ingroup TArray \fn asin(const TArray<T>& a)
+/*! \ingroup TArray \fn Asin(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> asin(const TArray<T>& a)
+inline TArray<T> Asin(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, asin) ); }
 
-/*! \ingroup TArray \fn acos(const TArray<T>& a)
+/*! \ingroup TArray \fn Acos(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> acos(const TArray<T>& a)
+inline TArray<T> Acos(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, acos) ); }
 
-/*! \ingroup TArray \fn atan(const TArray<T>& a)
+/*! \ingroup TArray \fn Atan(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> atan(const TArray<T>& a)
+inline TArray<T> Atan(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, atan) ); }
 
-/*! \ingroup TArray \fn exp(const TArray<T>& a)
+/*! \ingroup TArray \fn Exp(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> exp(const TArray<T>& a)
+inline TArray<T> Exp(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, exp) ); }
 
-/*! \ingroup TArray \fn lof(const TArray<T>& a)
+/*! \ingroup TArray \fn Log(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> log(const TArray<T>& a)
+inline TArray<T> Log(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, log) ); }
 
-/*! \ingroup TArray \fn log10(const TArray<T>& a)
+/*! \ingroup TArray \fn Log10(const TArray<T>& a)
   \brief computation on TArray */
 template <class T>
-inline TArray<T> log10(const TArray<T>& a)
+inline TArray<T> Log10(const TArray<T>& a)
   { MathArray<T> ma;   return( ma.ApplyFunction(a, log10) ); }
 
-#else
-// g++ (up to 2.95.1) doesn't handle these inline template
-// functions correctly - with math functions defined in math.h
-#include "gcc_arrmath_pb.h"
-#endif
 
 /*! \ingroup TArray \fn MeanSigma(const TArray<T>&,double&,double&)
