[Olena-patches] milena r1248: Rename x variables into t in accumulators

4 Oct 2007

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena

ChangeLog:
2007-10-04  Matthieu Garrigues  <garrigues@lrde.epita.fr>

	Rename x variables into t in accumulators.

	* mln/accu/count.hh,
	* mln/accu/histo.hh,
	* mln/accu/max.hh,
	* mln/accu/max_h.hh,
	* mln/accu/mean.hh,
	* mln/accu/median.hh,
	* mln/accu/median_alt.hh,
	* mln/accu/min.hh,
	* mln/accu/min_h.hh,
	* mln/accu/p.hh,
	* mln/accu/pair.hh,
	* mln/accu/sum.hh,
	* mln/accu/v.hh,
	* mln/core/concept/accumulator.hh,
	* mln/core/concept/doc/accumulator.hh: Rename.

	* tests/value_float01.cc: Fix warnings.

---
 mln/accu/count.hh                   |   36 +++++++++---------
 mln/accu/histo.hh                   |   20 +++++-----
 mln/accu/max.hh                     |   64 ++++++++++++++++----------------
 mln/accu/max_h.hh                   |   42 ++++++++++-----------
 mln/accu/mean.hh                    |   50 ++++++++++++-------------
 mln/accu/median.hh                  |   32 ++++++++--------
 mln/accu/median_alt.hh              |   42 ++++++++++-----------
 mln/accu/min.hh                     |   72 ++++++++++++++++++------------------
 mln/accu/min_h.hh                   |   42 ++++++++++-----------
 mln/accu/p.hh                       |   12 +++---
 mln/accu/pair.hh                    |   62 +++++++++++++++----------------
 mln/accu/sum.hh                     |   40 ++++++++++----------
 mln/accu/v.hh                       |   12 +++---
 mln/core/concept/accumulator.hh     |    2 -
 mln/core/concept/doc/accumulator.hh |    4 +-
 tests/value_float01.cc              |    8 ++--
 16 files changed, 270 insertions(+), 270 deletions(-)

Index: trunk/milena/tests/value_float01.cc
===================================================================

--- trunk/milena/tests/value_float01.cc	(revision 1247)
+++ trunk/milena/tests/value_float01.cc	(revision 1248)
@@ -48,11 +48,11 @@
 using namespace mln::value;
 using  mln::value::int_u8;
 
-float fi(int x) { return 0.5; }
-int ii(int x) { return 1; }
+float fi(int) { return 0.5; }
+int ii(int) { return 1; }
 
-float fd(double x) { return 0.5; }
-int id(double x) { return 1; }
+float fd(double) { return 0.5; }
+int id(double) { return 1; }
 
 
 struct tofloat01 : mln::Function_v2v<tofloat01>
Index: trunk/milena/mln/core/concept/doc/accumulator.hh
===================================================================
--- trunk/milena/mln/core/concept/doc/accumulator.hh	(revision 1247)
+++ trunk/milena/mln/core/concept/doc/accumulator.hh	(revision 1248)
@@ -50,8 +50,8 @@
       /// Initialize the accumulator.
       void init();
 
-      /// Take into account a argument \p x (an element).
-      void take(const argument& x);
+      /// Take into account a argument \p t (an element).
+      void take(const argument& t);
 
       /// Take into account another accumulator \p other.
       void take(const E& other);
Index: trunk/milena/mln/core/concept/accumulator.hh
===================================================================
--- trunk/milena/mln/core/concept/accumulator.hh	(revision 1247)
+++ trunk/milena/mln/core/concept/accumulator.hh	(revision 1248)
@@ -68,7 +68,7 @@
       typedef argument;
       typedef result;
       void init();
-      void take(const argument& x);
+      void take(const argument& t);
       void take(const E& other);
       result to_result() const;
       operator result_() const;
Index: trunk/milena/mln/accu/min.hh
===================================================================
--- trunk/milena/mln/accu/min.hh	(revision 1247)
+++ trunk/milena/mln/accu/min.hh	(revision 1248)
@@ -48,26 +48,26 @@
 
     /*! Generic min accumulator class.
      *
-     * The parameter \c V is the type of values.
+     * The parameter \c T is the type of values.
      */
-    template <typename V>
-    struct min_ : public mln::accu::internal::base_< V, min_<V> >
+    template <typename T>
+    struct min_ : public mln::accu::internal::base_< T, min_<T> >
     {
-      typedef V argument;
-      typedef V result;
+      typedef T argument;
+      typedef T result;
 
       min_();
 
       void init();
-      void take_as_init(const argument& x);
-      void take(const argument& x);
-      void take(const min_<V>& other);
+      void take_as_init(const argument& t);
+      void take(const argument& t);
+      void take(const min_<T>& other);
 
-      V to_result() const;
+      T to_result() const;
 
     protected:
 
-      V x_;
+      T t_;
     };
 
 
@@ -77,10 +77,10 @@
     // FIXME: Doc!
     struct min : public Meta_Accumulator< min >
     {
-      template <typename V>
+      template <typename T>
       struct with
       {
-	typedef min_<V> ret;
+	typedef min_<T> ret;
       };
     };
 
@@ -88,17 +88,17 @@
 
 //     // FIXME: Sample code.
 
-//     template <typename V>
-//     struct p_min_ : public p_< min_<V> >
+//     template <typename T>
+//     struct p_min_ : public p_< min_<T> >
 //     {
 //     };
 
 //     struct p_min : public Meta_Accumulator< p_min >
 //     {
-//       template <typename V>
+//       template <typename T>
 //       struct with
 //       {
-// 	typedef p_min_<V> ret;
+// 	typedef p_min_<T> ret;
 //       };
 //     };
 
@@ -106,45 +106,45 @@
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename V>
-    min_<V>::min_()
+    template <typename T>
+    min_<T>::min_()
     {
       init();
     }
 
-    template <typename V>
+    template <typename T>
     void
-    min_<V>::init()
+    min_<T>::init()
     {
-      x_ = mln_max(V);
+      t_ = mln_max(T);
     }
 
-    template <typename V>
-    void min_<V>::take_as_init(const argument& x)
+    template <typename T>
+    void min_<T>::take_as_init(const argument& t)
     {
-      x_ = x;
+      t_ = t;
     }
 
-    template <typename V>
-    void min_<V>::take(const argument& x)
+    template <typename T>
+    void min_<T>::take(const argument& t)
     {
-      if (x < x_)
-	x_ = x;
+      if (t < t_)
+	t_ = t;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    min_<V>::take(const min_<V>& other)
+    min_<T>::take(const min_<T>& other)
     {
-      if (other.x_ < x_)
-	x_ = other.x_;
+      if (other.t_ < t_)
+	t_ = other.t_;
     }
 
-    template <typename V>
-    V
-    min_<V>::to_result() const
+    template <typename T>
+    T
+    min_<T>::to_result() const
     {
-      return x_;
+      return t_;
     }
 
 # endif // ! MLN_INCLUDE_ONLY
Index: trunk/milena/mln/accu/max.hh
===================================================================
--- trunk/milena/mln/accu/max.hh	(revision 1247)
+++ trunk/milena/mln/accu/max.hh	(revision 1248)
@@ -47,26 +47,26 @@
 
     /*! Generic max accumulator class.
      *
-     * The parameter \c V is the type of values.
+     * The parameter \c T is the type of values.
      */
-    template <typename V>
-    struct max_ : public mln::accu::internal::base_< V , max_<V> >
+    template <typename T>
+    struct max_ : public mln::accu::internal::base_< T , max_<T> >
     {
-      typedef V argument;
-      typedef V result;
+      typedef T argument;
+      typedef T result;
 
       max_();
 
       void init();
-      void take_as_init(const argument& x);
-      void take(const argument& x);
-      void take(const max_<V>& other);
+      void take_as_init(const argument& t);
+      void take(const argument& t);
+      void take(const max_<T>& other);
 
-      V to_result() const;
+      T to_result() const;
 
     protected:
 
-      V x_;
+      T t_;
     };
 
 
@@ -76,10 +76,10 @@
     // FIXME: Doc!
     struct max : public Meta_Accumulator< max >
     {
-      template <typename V>
+      template <typename T>
       struct with
       {
-	typedef max_<V> ret;
+	typedef max_<T> ret;
       };
     };
 
@@ -87,47 +87,47 @@
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename V>
-    max_<V>::max_()
+    template <typename T>
+    max_<T>::max_()
     {
       init();
     }
 
-    template <typename V>
+    template <typename T>
     void
-    max_<V>::init()
+    max_<T>::init()
     {
-      x_ = mln_min(V);
+      t_ = mln_min(T);
     }
 
-    template <typename V>
+    template <typename T>
     void
-    max_<V>::take_as_init(const argument& x)
+    max_<T>::take_as_init(const argument& t)
     {
-      x_ = x;
+      t_ = t;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    max_<V>::take(const argument& x)
+    max_<T>::take(const argument& t)
     {
-      if (x > x_)
-	x_ = x;
+      if (t > t_)
+	t_ = t;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    max_<V>::take(const max_<V>& other)
+    max_<T>::take(const max_<T>& other)
     {
-      if (other.x_ > x_)
-	x_ = other.x_;
+      if (other.t_ > t_)
+	t_ = other.t_;
     }
 
-    template <typename V>
-    V
-    max_<V>::to_result() const
+    template <typename T>
+    T
+    max_<T>::to_result() const
     {
-      return x_;
+      return t_;
     }
 
 # endif // ! MLN_INCLUDE_ONLY
Index: trunk/milena/mln/accu/histo.hh
===================================================================
--- trunk/milena/mln/accu/histo.hh	(revision 1247)
+++ trunk/milena/mln/accu/histo.hh	(revision 1248)
@@ -61,12 +61,12 @@
       typedef mln_value(S) argument;
       typedef const std::vector<std::size_t>& result;
 
-      void   take(const argument& x);
+      void   take(const argument& t);
       void   take(const histo<S>& other);
-      void untake(const argument& x);
+      void untake(const argument& t);
       void init();
 
-      std::size_t operator()(const argument& x) const;
+      std::size_t operator()(const argument& t) const;
       std::size_t operator[](std::size_t i) const;
       std::size_t nvalues() const;
       std::size_t sum() const;
@@ -110,9 +110,9 @@
 
     template <typename S>
     void
-    histo<S>::take(const argument& x)
+    histo<S>::take(const argument& t)
     {
-      ++h_[s_.index_of(x)];
+      ++h_[s_.index_of(t)];
       ++sum_;
     }
 
@@ -127,11 +127,11 @@
 
     template <typename S>
     void
-    histo<S>::untake(const argument& x)
+    histo<S>::untake(const argument& t)
     {
-      mln_precondition(h_[s_.index_of(x)] > 0);
+      mln_precondition(h_[s_.index_of(t)] > 0);
       mln_precondition(sum_ > 0);
-      --h_[s_.index_of(x)];
+      --h_[s_.index_of(t)];
       --sum_;
     }
 
@@ -145,9 +145,9 @@
 
     template <typename S>
     std::size_t
-    histo<S>::operator()(const argument& x) const
+    histo<S>::operator()(const argument& t) const
     {
-      return h_[s_.index_of(x)];
+      return h_[s_.index_of(t)];
     }
 
     template <typename S>
Index: trunk/milena/mln/accu/count.hh
===================================================================
--- trunk/milena/mln/accu/count.hh	(revision 1247)
+++ trunk/milena/mln/accu/count.hh	(revision 1248)
@@ -46,17 +46,17 @@
 
     /*! Generic counter accumulator class.
      */
-    template <typename V>
-    struct count_ : public mln::accu::internal::base_< std::size_t , count_<V> >
+    template <typename T>
+    struct count_ : public mln::accu::internal::base_< std::size_t , count_<T> >
     {
-      typedef V argument;
+      typedef T argument;
       typedef std::size_t result; // FIXME: Up in Accumulator.
 
       count_();
 
       void init();
       void take(const argument&);
-      void take(const count_<V>& other);
+      void take(const count_<T>& other);
 
       std::size_t to_result() const;
       void set_value(std::size_t c);
@@ -70,53 +70,53 @@
     // FIXME: Doc!
     struct count : public Meta_Accumulator< count >
     {
-      template <typename V>
+      template <typename T>
       struct with
       {
-	typedef count_<V> ret;
+	typedef count_<T> ret;
       };
     };
 
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename V>
-    count_<V>::count_()
+    template <typename T>
+    count_<T>::count_()
     {
       init();
     }
 
-    template <typename V>
+    template <typename T>
     void
-    count_<V>::init()
+    count_<T>::init()
     {
       count__ = 0;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    count_<V>::take(const argument&)
+    count_<T>::take(const argument&)
     {
       ++count__;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    count_<V>::take(const count_<V>& other)
+    count_<T>::take(const count_<T>& other)
     {
       count__ += other.count__;
     }
 
-    template <typename V>
+    template <typename T>
     std::size_t
-    count_<V>::to_result() const
+    count_<T>::to_result() const
     {
       return count__;
     }
 
-    template <typename V>
+    template <typename T>
     void
-    count_<V>::set_value(std::size_t c)
+    count_<T>::set_value(std::size_t c)
     {
       count__ = c;
     }
Index: trunk/milena/mln/accu/min_h.hh
===================================================================
--- trunk/milena/mln/accu/min_h.hh	(revision 1247)
+++ trunk/milena/mln/accu/min_h.hh	(revision 1248)
@@ -57,10 +57,10 @@
       min_h();
 
       void init();
-      void   take(const argument& x);
-      void   take_as_init(const argument& x);
+      void   take(const argument& t);
+      void   take_as_init(const argument& t);
       void   take(const min_h<S>& other);
-      void untake(const argument& x);
+      void untake(const argument& t);
 
       unsigned card() const { return h_.sum(); }
 
@@ -76,7 +76,7 @@
       mutable std::size_t sum_;
       mutable bool valid_;
       mutable std::size_t i_; // the min index
-      mutable argument x_;       // the min value
+      mutable argument t_;       // the min value
 
       // Auxiliary methods
       void update_() const;
@@ -105,15 +105,15 @@
 
     template <typename S>
     void
-    min_h<S>::take(const argument& x)
+    min_h<S>::take(const argument& t)
     {
-      h_.take(x);
+      h_.take(t);
       if (h_.sum() == 1)
 	{
-	  this->take_as_init(x);
+	  this->take_as_init(t);
 	  return;
 	}
-      if (x < x_)
+      if (t < t_)
 	{
 	  ++sum_;
 	  valid_ = false;
@@ -134,23 +134,23 @@
 
     template <typename S>
     void
-    min_h<S>::untake(const argument& x)
+    min_h<S>::untake(const argument& t)
     {
-      mln_precondition(h_(x) != 0);
-      h_.untake(x);
+      mln_precondition(h_(t) != 0);
+      h_.untake(t);
       if (h_.sum() == 0)
 	{
 	  init();
 	  return;
 	}
-      if (x < x_)
+      if (t < t_)
 	{
 	  mln_invariant(sum_ >= 1);
 	  --sum_;
 	  valid_ = false;
 	}
       else
-	if (x == x_ && h_[i_] == 0)
+	if (t == t_ && h_[i_] == 0)
 	  valid_ = false;
     }
 
@@ -177,7 +177,7 @@
 	    sum_ -= h_[i_];
 	}
       while (sum_ != 0);
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -187,7 +187,7 @@
       do
 	++i_;
       while (h_[i_] == 0);
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -197,18 +197,18 @@
       h_.init();
       sum_ = 0;
       i_ = mln_max(argument);
-      x_ = s_[i_];
+      t_ = s_[i_];
       valid_ = true;
     }
 
     template <typename S>
     void
-    min_h<S>::take_as_init(const argument& x)
+    min_h<S>::take_as_init(const argument& t)
     {
-      h_.take(x);
+      h_.take(t);
       sum_ = 0;
-      i_ = s_.index_of(x);
-      x_ = x;
+      i_ = s_.index_of(t);
+      t_ = t;
       valid_ = true;
     }
 
@@ -218,7 +218,7 @@
     {
       if (! valid_)
 	update_();
-      return x_;
+      return t_;
     }
 
     template <typename S>
Index: trunk/milena/mln/accu/pair.hh
===================================================================
--- trunk/milena/mln/accu/pair.hh	(revision 1247)
+++ trunk/milena/mln/accu/pair.hh	(revision 1248)
@@ -51,14 +51,14 @@
 
     /*! Generic pair of accumulators.
      *
-     * The parameter \c V is the type of values.
+     * The parameter \c T is the type of values.
      *
-     * \todo Check that, when V is not provided, A1 and A2 have the same value.
+     * \todo Check that, when T is not provided, A1 and A2 have the same value.
      */
-    template <typename A1, typename A2, typename V = mln_argument(A1)>
-    struct pair_ : public mln::accu::internal::base_< std::pair< mlc_unqualif(mln_result(A1)) , mlc_unqualif(mln_result(A2)) > , pair_<A1,A2,V> >
+    template <typename A1, typename A2, typename T = mln_argument(A1)>
+    struct pair_ : public mln::accu::internal::base_< std::pair< mlc_unqualif(mln_result(A1)) , mlc_unqualif(mln_result(A2)) > , pair_<A1,A2,T> >
     {
-      typedef V argument;
+      typedef T argument;
 
       typedef mlc_unqualif(mln_result(A1))  result_1;
       typedef mlc_unqualif(mln_result(A2))  result_2;
@@ -68,9 +68,9 @@
       pair_(const A1& a1, const A2& a2);
 
       void init();
-      void take_as_init(const argument& x);
-      void take(const argument& x);
-      void take(const pair_<A1,A2,V>& other);
+      void take_as_init(const argument& t);
+      void take(const argument& t);
+      void take(const pair_<A1,A2,T>& other);
 
       result to_result() const;
       void get_result(result_1& r1, result_2& r2) const;
@@ -87,67 +87,67 @@
     template <typename A1, typename A2>
     struct pair : public Meta_Accumulator< pair<A1,A2> >
     {
-      template <typename V>
+      template <typename T>
       struct with
       {
-	typedef mln_accu_with(A1, V) A1_V;
-	typedef mln_accu_with(A2, V) A2_V;
-	typedef pair_<A1_V, A2_V, V> ret;
+	typedef mln_accu_with(A1, T) A1_T;
+	typedef mln_accu_with(A2, T) A2_T;
+	typedef pair_<A1_T, A2_T, T> ret;
       };
     };
 
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename A1, typename A2, typename V>
-    pair_<A1,A2,V>::pair_()
+    template <typename A1, typename A2, typename T>
+    pair_<A1,A2,T>::pair_()
     {
       init();
     }
 
-    template <typename A1, typename A2, typename V>
+    template <typename A1, typename A2, typename T>
     void
-    pair_<A1,A2,V>::init()
+    pair_<A1,A2,T>::init()
     {
       a1_.init();
       a2_.init();
     }
 
-    template <typename A1, typename A2, typename V>
+    template <typename A1, typename A2, typename T>
     void
-    pair_<A1,A2,V>::take_as_init(const argument& x)
+    pair_<A1,A2,T>::take_as_init(const argument& t)
     {
-      a1_.take_as_init(x);
-      a2_.take_as_init(x);
+      a1_.take_as_init(t);
+      a2_.take_as_init(t);
     }
 
-    template <typename A1, typename A2, typename V>
+    template <typename A1, typename A2, typename T>
     void
-    pair_<A1,A2,V>::take(const argument& x)
+    pair_<A1,A2,T>::take(const argument& t)
     {
-      a1_.take(x);
-      a2_.take(x);
+      a1_.take(t);
+      a2_.take(t);
     }
 
-    template <typename A1, typename A2, typename V>
+    template <typename A1, typename A2, typename T>
     void
-    pair_<A1,A2,V>::take(const pair_<A1,A2,V>& other)
+    pair_<A1,A2,T>::take(const pair_<A1,A2,T>& other)
     {
       a1_.take(other.a1_);
       a2_.take(other.a2_);
     }
 
-    template <typename A1, typename A2, typename V>
-    typename pair_<A1,A2,V>::result
-    pair_<A1,A2,V>::to_result() const
+    template <typename A1, typename A2, typename T>
+    typename pair_<A1,A2,T>::result
+    pair_<A1,A2,T>::to_result() const
     {
       result tmp(a1_.to_result(), a2_.to_result());
       return tmp;
     }
 
-    template <typename A1, typename A2, typename V>
+    template <typename A1, typename A2, typename T>
     void
-    pair_<A1,A2,V>::get_result(result_1& r1,
+    pair_<A1,A2,T>::get_result(result_1& r1,
 			    result_2& r2) const
     {
       r1 = a1_.to_result();
Index: trunk/milena/mln/accu/max_h.hh
===================================================================
--- trunk/milena/mln/accu/max_h.hh	(revision 1247)
+++ trunk/milena/mln/accu/max_h.hh	(revision 1248)
@@ -57,10 +57,10 @@
       max_h();
 
       void init();
-      void   take(const argument& x);
-      void   take_as_init(const argument& x);
+      void   take(const argument& t);
+      void   take_as_init(const argument& t);
       void   take(const max_h<S>& other);
-      void untake(const argument& x);
+      void untake(const argument& t);
 
       unsigned card() const { return h_.sum(); }
 
@@ -76,7 +76,7 @@
       mutable std::size_t sum_;
       mutable bool valid_;
       mutable std::size_t i_; // the max index
-      mutable argument x_;       // the max argument
+      mutable argument t_;       // the max argument
 
       // Auxiliary methods
       void update_() const;
@@ -105,15 +105,15 @@
 
     template <typename S>
     void
-    max_h<S>::take(const argument& x)
+    max_h<S>::take(const argument& t)
     {
-      h_.take(x);
+      h_.take(t);
       if (h_.sum() == 1)
 	{
-	  this->take_as_init(x);
+	  this->take_as_init(t);
 	  return;
 	}
-      if (x > x_)
+      if (t > t_)
 	{
 	  ++sum_;
 	  valid_ = false;
@@ -134,23 +134,23 @@
 
     template <typename S>
     void
-    max_h<S>::untake(const argument& x)
+    max_h<S>::untake(const argument& t)
     {
-      mln_precondition(h_(x) != 0);
-      h_.untake(x);
+      mln_precondition(h_(t) != 0);
+      h_.untake(t);
       if (h_.sum() == 0)
 	{
 	  init();
 	  return;
 	}
-      if (x > x_)
+      if (t > t_)
 	{
 	  mln_invariant(sum_ >= 1);
 	  --sum_;
 	  valid_ = false;
 	}
       else
-	if (x == x_ && h_[i_] == 0)
+	if (t == t_ && h_[i_] == 0)
 	  valid_ = false;
     }
 
@@ -173,7 +173,7 @@
       do
 	--i_;
       while (h_[i_] == 0);
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -186,7 +186,7 @@
 	if (h_[i_] != 0)
 	  sum_ -= h_[i_];
       } while (sum_ != 0);
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -196,18 +196,18 @@
       h_.init();
       sum_ = 0;
       i_ = mln_min(argument);
-      x_ = s_[i_];
+      t_ = s_[i_];
       valid_ = true;
     }
 
     template <typename S>
     void
-    max_h<S>::take_as_init(const argument& x)
+    max_h<S>::take_as_init(const argument& t)
     {
-      h_.take(x);
+      h_.take(t);
       sum_ = 0;
-      i_ = s_.index_of(x);
-      x_ = x;
+      i_ = s_.index_of(t);
+      t_ = t;
       valid_ = true;
     }
 
@@ -217,7 +217,7 @@
     {
       if (! valid_)
 	update_();
-      return x_;
+      return t_;
     }
 
     template <typename S>
Index: trunk/milena/mln/accu/median.hh
===================================================================
--- trunk/milena/mln/accu/median.hh	(revision 1247)
+++ trunk/milena/mln/accu/median.hh	(revision 1248)
@@ -57,9 +57,9 @@
       median();
 
       void init();
-      void   take(const argument& x);
+      void   take(const argument& t);
       void   take(const median<S>& other);
-      void untake(const argument& x);
+      void untake(const argument& t);
 
       unsigned card() const { return h_.sum(); }
 
@@ -76,7 +76,7 @@
 
       mutable bool valid_;
       mutable std::size_t i_; // the median index
-      mutable argument x_;       // the median value
+      mutable argument t_;       // the median value
 
       // Auxiliary methods
       void update_() const;
@@ -105,13 +105,13 @@
 
     template <typename S>
     void
-    median<S>::take(const argument& x)
+    median<S>::take(const argument& t)
     {
-      h_.take(x);
+      h_.take(t);
 
-      if (x < x_)
+      if (t < t_)
 	++sum_minus_;
-      else if (x > x_)
+      else if (t > t_)
 	++sum_plus_;
 
       if (valid_)
@@ -139,14 +139,14 @@
 
     template <typename S>
     void
-    median<S>::untake(const argument& x)
+    median<S>::untake(const argument& t)
     {
-      mln_precondition(h_(x) != 0);
-      h_.untake(x);
+      mln_precondition(h_(t) != 0);
+      h_.untake(t);
 
-      if (x < x_)
+      if (t < t_)
 	--sum_minus_;
-      else if (x > x_)
+      else if (t > t_)
 	--sum_plus_;
 
       if (valid_)
@@ -191,7 +191,7 @@
 	  sum_minus_ -= h_[i_];
 	}
       while (2 * sum_minus_ > h_.sum());
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -207,7 +207,7 @@
 	  sum_plus_ -= h_[i_];
 	}
       while (2 * sum_plus_ > h_.sum());
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
@@ -218,7 +218,7 @@
       sum_minus_ = 0;
       sum_plus_ = 0;
       i_ = (mln_max(argument) - mln_min(argument)) / 2;
-      x_ = s_[i_];
+      t_ = s_[i_];
       valid_ = true;
     }
 
@@ -228,7 +228,7 @@
     {
       if (! valid_)
 	update_();
-      return x_;
+      return t_;
     }
 
     template <typename S>
Index: trunk/milena/mln/accu/median_alt.hh
===================================================================
--- trunk/milena/mln/accu/median_alt.hh	(revision 1247)
+++ trunk/milena/mln/accu/median_alt.hh	(revision 1248)
@@ -54,8 +54,8 @@
 
       median_alt(const Value_Set<S>& s);
 
-      void   take(const argument& x);
-      void untake(const argument& x);
+      void   take(const argument& t);
+      void untake(const argument& t);
       void init();
 
       argument to_result() const;
@@ -64,7 +64,7 @@
       void debug__() const
       {
 	std::cout << "  i = " << i_
-		  << "  x = " << x_
+		  << "  t = " << t_
 		  << "  s = " << sum_minus_ << " ; " << h_[i_] << " ; " << sum_plus_ << " = " << h_.sum()
 		  << std::endl;
       }
@@ -77,7 +77,7 @@
       std::size_t sum_minus_, sum_plus_;
 
       std::size_t i_; // the median index
-      argument x_;       // the median argument
+      argument t_;       // the median argument
 
       // Auxiliary methods
       void go_minus_();
@@ -109,24 +109,24 @@
 
     template <typename S>
     void
-    median_alt<S>::take(const argument& x)
+    median_alt<S>::take(const argument& t)
     {
       // update h_
-      h_.take(x);
+      h_.take(t);
 
       // particular case:
       // current state was initialization
       if (h_[i_] == 0)
 	{
 	  // std::cout << "init!" << std::endl;
-	  i_ = s_.index_of(x);
-	  x_ = x;
+	  i_ = s_.index_of(t);
+	  t_ = t;
 	  return;
 	}
 
       // particular case:
       // the median does not change
-      if (x == x_)
+      if (t == t_)
 	{
 	  // std::cout << "no change!" << std::endl;
 	  return;
@@ -134,14 +134,14 @@
 
       // general case:
 
-      if (x < x_)
+      if (t < t_)
 	{
 	  ++sum_minus_;
 	  if (2 * sum_minus_ > h_.sum())
 	    go_minus_();
 	}
       else
-	// x > x_
+	// t > t_
 	{
 	  ++sum_plus_;
 	  if (2 * sum_plus_ > h_.sum())
@@ -152,12 +152,12 @@
 
     template <typename S>
     void
-    median_alt<S>::untake(const argument& x)
+    median_alt<S>::untake(const argument& t)
     {
-      mln_precondition(h_(x) != 0);
+      mln_precondition(h_(t) != 0);
 
       // update h_
-      h_.untake(x);
+      h_.untake(t);
 
       // particular case:
       // the only value has been removed
@@ -168,20 +168,20 @@
 	}
 
       // general case:
-      if (x < x_)
+      if (t < t_)
 	{
 	  --sum_minus_;
 	  if (2 * sum_plus_ > h_.sum())
 	    go_plus_();
 	}
-      else if (x > x_)
+      else if (t > t_)
 	{
 	  --sum_plus_;
 	  if (2 * sum_minus_ > h_.sum())
 	    go_minus_();
 	}
       else
-	// x == x_
+	// t == t_
 	{
 	  if (h_[i_] == 0)
 	    {
@@ -216,7 +216,7 @@
 	  sum_minus_ -= h_[i_];
 	}
       while (2 * sum_minus_ > h_.sum());
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
 
@@ -233,7 +233,7 @@
 	  sum_plus_ -= h_[i_];
 	}
       while (2 * sum_plus_ > h_.sum());
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
 
@@ -245,14 +245,14 @@
       sum_minus_ = 0;
       sum_plus_ = 0;
       i_ = (mln_max(argument) - mln_min(argument)) / 2;
-      x_ = s_[i_];
+      t_ = s_[i_];
     }
 
     template <typename S>
     typename median_alt<S>::argument
     median_alt<S>::to_result() const
     {
-      return x_;
+      return t_;
     }
 
     template <typename S>
Index: trunk/milena/mln/accu/p.hh
===================================================================
--- trunk/milena/mln/accu/p.hh	(revision 1247)
+++ trunk/milena/mln/accu/p.hh	(revision 1248)
@@ -61,8 +61,8 @@
       p_(const A& a);
 
       void init();
-      void take_as_init(const argument& x);
-      void take(const argument& x);
+      void take_as_init(const argument& t);
+      void take(const argument& t);
       void take(const p_<A>& other);
 
       result to_result() const;
@@ -109,16 +109,16 @@
 
     template <typename A>
     void
-    p_<A>::take_as_init(const argument& x)
+    p_<A>::take_as_init(const argument& t)
     {
-      a_.take_as_init(x.p()); // FIXME: Generalize with "psite(x)".
+      a_.take_as_init(t.p()); // FIXME: Generalize with "psite(t)".
     }
 
     template <typename A>
     void
-    p_<A>::take(const argument& x)
+    p_<A>::take(const argument& t)
     {
-      a_.take(x.p());
+      a_.take(t.p());
     }
 
     template <typename A>
Index: trunk/milena/mln/accu/sum.hh
===================================================================
--- trunk/milena/mln/accu/sum.hh	(revision 1247)
+++ trunk/milena/mln/accu/sum.hh	(revision 1248)
@@ -50,21 +50,21 @@
 
     /*! Generic sum accumulator class.
      *
-     * Parameter \c V is the type of values that we sum.  Parameter \c
+     * Parameter \c T is the type of values that we sum.  Parameter \c
      * S is the type to store the value sum; the default type of
-     * \c S is the summation type (property) of \c V.
+     * \c S is the summation type (property) of \c T.
      */
-    template <typename V, typename S = mln_sum(V)>
-    struct sum_ : public mln::accu::internal::base_< S, sum_<V,S> >
+    template <typename T, typename S = mln_sum(T)>
+    struct sum_ : public mln::accu::internal::base_< S, sum_<T,S> >
     {
-      typedef V argument;
+      typedef T argument;
       typedef S result;
 
       sum_();
 
       void init();
-      void take(const argument& x);
-      void take(const sum_<V,S>& other);
+      void take(const argument& t);
+      void take(const sum_<T,S>& other);
 
       S to_result() const;
 
@@ -81,10 +81,10 @@
     // FIXME: Doc!
     struct sum : public Meta_Accumulator< sum >
     {
-      template <typename V, typename S = mln_sum(V)>
+      template <typename T, typename S = mln_sum(T)>
       struct with
       {
-	typedef sum_<V, S> ret;
+	typedef sum_<T, S> ret;
       };
     };
 
@@ -92,35 +92,35 @@
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename V, typename S>
-    sum_<V,S>::sum_()
+    template <typename T, typename S>
+    sum_<T,S>::sum_()
     {
       init();
     }
 
-    template <typename V, typename S>
+    template <typename T, typename S>
     void
-    sum_<V,S>::init()
+    sum_<T,S>::init()
     {
       s_ = literal::zero;
     }
 
-    template <typename V, typename S>
-    void sum_<V,S>::take(const argument& x)
+    template <typename T, typename S>
+    void sum_<T,S>::take(const argument& t)
     {
-      s_ += x;
+      s_ += t;
     }
 
-    template <typename V, typename S>
+    template <typename T, typename S>
     void
-    sum_<V,S>::take(const sum_<V,S>& other)
+    sum_<T,S>::take(const sum_<T,S>& other)
     {
       s_ += other.s_;
     }
 
-    template <typename V, typename S>
+    template <typename T, typename S>
     S
-    sum_<V,S>::to_result() const
+    sum_<T,S>::to_result() const
     {
       return s_;
     }
Index: trunk/milena/mln/accu/v.hh
===================================================================
--- trunk/milena/mln/accu/v.hh	(revision 1247)
+++ trunk/milena/mln/accu/v.hh	(revision 1248)
@@ -57,8 +57,8 @@
       val_(const A& a);
 
       void init();
-      void take_as_init(const argument& x);
-      void take(const argument& x);
+      void take_as_init(const argument& t);
+      void take(const argument& t);
       void take(const val_<A>& other);
 
       template <typename I>
@@ -118,16 +118,16 @@
 
     template <typename A>
     void
-    val_<A>::take_as_init(const argument& x)
+    val_<A>::take_as_init(const argument& t)
     {
-      a_.take_as_init(x);
+      a_.take_as_init(t);
     }
 
     template <typename A>
     void
-    val_<A>::take(const argument& x)
+    val_<A>::take(const argument& t)
     {
-      a_.take(x);
+      a_.take(t);
     }
 
     template <typename A>
Index: trunk/milena/mln/accu/mean.hh
===================================================================
--- trunk/milena/mln/accu/mean.hh	(revision 1247)
+++ trunk/milena/mln/accu/mean.hh	(revision 1248)
@@ -49,32 +49,32 @@
 
     /*! Generic mean accumulator class.
      *
-     * Parameter \c V is the type of values that we sum.  Parameter \c
+     * Parameter \c T is the type of values that we sum.  Parameter \c
      * S is the type to store the sum of values; the default type of
-     * \c S is the summation type (property) of \c V.  Parameter \c M
+     * \c S is the summation type (property) of \c T.  Parameter \c M
      * is the type of the mean value; the default type of \c M is \c
      * S.
      */
-    template <typename V,
-	      typename S = mln_sum(V),
+    template <typename T,
+	      typename S = mln_sum(T),
 	      typename M = S>
-    struct mean_ : public mln::accu::internal::base_< M , mean_<V,S,M> >
+    struct mean_ : public mln::accu::internal::base_< M , mean_<T,S,M> >
     {
-      typedef V argument;
+      typedef T argument;
       typedef M result;
 
       mean_();
 
       void init();
-      void take(const argument& x);
-      void take(const mean_<V,S,M>& other);
+      void take(const argument& t);
+      void take(const mean_<T,S,M>& other);
 
       M to_result() const;
 
     protected:
 
-      accu::count_<V> count_;
-      accu::sum_<V,S>   sum_;
+      accu::count_<T> count_;
+      accu::sum_<T,S>   sum_;
     };
 
 
@@ -87,50 +87,50 @@
     // FIXME: Doc!
     struct mean : public Meta_Accumulator< mean >
     {
-      template < typename V,
-		 typename S = mln_sum(V),
+      template < typename T,
+		 typename S = mln_sum(T),
 		 typename M = S >
       struct with
       {
-	typedef mean_<V,S,M> ret;
+	typedef mean_<T,S,M> ret;
       };
     };
 
 
 # ifndef MLN_INCLUDE_ONLY
 
-    template <typename V, typename S, typename M>
-    mean_<V,S,M>::mean_()
+    template <typename T, typename S, typename M>
+    mean_<T,S,M>::mean_()
     {
       init();
     }
 
-    template <typename V, typename S, typename M>
+    template <typename T, typename S, typename M>
     void
-    mean_<V,S,M>::init()
+    mean_<T,S,M>::init()
     {
       count_.init();
       sum_.init();
     }
 
-    template <typename V, typename S, typename M>
-    void mean_<V,S,M>::take(const argument& x)
+    template <typename T, typename S, typename M>
+    void mean_<T,S,M>::take(const argument& t)
     {
-      count_.take(x);
-      sum_.take(x);
+      count_.take(t);
+      sum_.take(t);
     }
 
-    template <typename V, typename S, typename M>
+    template <typename T, typename S, typename M>
     void
-    mean_<V,S,M>::take(const mean_<V,S,M>& other)
+    mean_<T,S,M>::take(const mean_<T,S,M>& other)
     {
       count_.take(other.count_);
       sum_.take(other.sum_);
     }
 
-    template <typename V, typename S, typename M>
+    template <typename T, typename S, typename M>
     M
-    mean_<V,S,M>::to_result() const
+    mean_<T,S,M>::to_result() const
     {
       return sum_.to_result() / count_.to_result();
     }

    