libstdc++/55169

Paolo Carlini paolo.carlini@oracle.com
Fri Nov 2 00:40:00 GMT 2012


... this is a more complete fix, because consistently it also makes 
sure  that we don't use param() anywhere else, ie, in operator==. 
Obvious, in hindsight. I'm still not doing anything about those two uses 
of param() in chi_squared_distribution, waiting for Ed's suggestions...

Thanks,
Paolo.

/////////////////////
-------------- next part --------------
Index: include/bits/random.h
===================================================================
--- include/bits/random.h	(revision 193079)
+++ include/bits/random.h	(working copy)
@@ -1767,7 +1767,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-        { return this->operator()(__urng, this->param()); }
+        { return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -1779,7 +1779,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -1796,6 +1796,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two uniform integer distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+		 const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -1809,16 +1818,6 @@
 
   /**
    * @brief Return true if two uniform integer distributions have
-   *        the same parameters.
-   */
-  template<typename _IntType>
-    inline bool
-    operator==(const std::uniform_int_distribution<_IntType>& __d1,
-	       const std::uniform_int_distribution<_IntType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
-   * @brief Return true if two uniform integer distributions have
    *        different parameters.
    */
   template<typename _IntType>
@@ -1972,7 +1971,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-        { return this->operator()(__urng, this->param()); }
+        { return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -1989,7 +1988,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2006,6 +2005,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two uniform real distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const uniform_real_distribution& __d1,
+		 const uniform_real_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2019,16 +2027,6 @@
 
   /**
    * @brief Return true if two uniform real distributions have
-   *        the same parameters.
-   */
-  template<typename _IntType>
-    inline bool
-    operator==(const std::uniform_real_distribution<_IntType>& __d1,
-	       const std::uniform_real_distribution<_IntType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
-   * @brief Return true if two uniform real distributions have
    *        different parameters.
    */
   template<typename _IntType>
@@ -2195,7 +2193,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -2207,7 +2205,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2397,7 +2395,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+        { return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -2410,7 +2408,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2435,7 +2433,7 @@
       friend bool
       operator==(const lognormal_distribution& __d1,
 		 const lognormal_distribution& __d2)
-      { return (__d1.param() == __d2.param()
+      { return (__d1._M_param == __d2._M_param
 		&& __d1._M_nd == __d2._M_nd); }
 
       /**
@@ -2619,7 +2617,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -2631,7 +2629,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2656,7 +2654,7 @@
       friend bool
       operator==(const gamma_distribution& __d1,
 		 const gamma_distribution& __d2)
-      { return (__d1.param() == __d2.param()
+      { return (__d1._M_param == __d2._M_param
 		&& __d1._M_nd == __d2._M_nd); }
 
       /**
@@ -2824,7 +2822,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate_impl(__f, __t, __urng, _M_gd.param()); }
+        { this->__generate_impl(__f, __t, __urng, _M_gd.param()); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -2861,7 +2859,7 @@
       friend bool
       operator==(const chi_squared_distribution& __d1,
 		 const chi_squared_distribution& __d2)
-      { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
 
       /**
        * @brief Inserts a %chi_squared_distribution random number distribution
@@ -3024,7 +3022,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -3036,7 +3034,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -3053,6 +3051,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two Cauchy distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const cauchy_distribution& __d1,
+		 const cauchy_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -3066,16 +3073,6 @@
 
   /**
    * @brief Return true if two Cauchy distributions have
-   *        the same parameters.
-   */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::cauchy_distribution<_RealType>& __d1,
-	       const std::cauchy_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
-   * @brief Return true if two Cauchy distributions have
    *        different parameters.
    */
   template<typename _RealType>
@@ -3278,7 +3275,7 @@
       friend bool
       operator==(const fisher_f_distribution& __d1,
 		 const fisher_f_distribution& __d2)
-      { return (__d1.param() == __d2.param()
+      { return (__d1._M_param == __d2._M_param
 		&& __d1._M_gd_x == __d2._M_gd_x
 		&& __d1._M_gd_y == __d2._M_gd_y); }
 
@@ -3492,7 +3489,7 @@
       friend bool
       operator==(const student_t_distribution& __d1,
 		 const student_t_distribution& __d2)
-      { return (__d1.param() == __d2.param()
+      { return (__d1._M_param == __d2._M_param
 		&& __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
 
       /**
@@ -3664,7 +3661,7 @@
     template<typename _UniformRandomNumberGenerator>
       result_type
       operator()(_UniformRandomNumberGenerator& __urng)
-      { return this->operator()(__urng, this->param()); }
+      { return this->operator()(__urng, _M_param); }
 
     template<typename _UniformRandomNumberGenerator>
       result_type
@@ -3684,7 +3681,7 @@
       void
       __generate(_ForwardIterator __f, _ForwardIterator __t,
 		 _UniformRandomNumberGenerator& __urng)
-      { this->__generate(__f, __t, __urng, this->param()); }
+      { this->__generate(__f, __t, __urng, _M_param); }
 
     template<typename _ForwardIterator,
 	     typename _UniformRandomNumberGenerator>
@@ -3700,6 +3697,15 @@
 		 const param_type& __p)
       { this->__generate_impl(__f, __t, __urng, __p); }
 
+    /**
+     * @brief Return true if two Bernoulli distributions have
+     *        the same parameters.
+     */
+    friend bool
+    operator==(const bernoulli_distribution& __d1,
+	       const bernoulli_distribution& __d2)
+    { return __d1._M_param == __d2._M_param; }
+
   private:
     template<typename _ForwardIterator,
 	     typename _UniformRandomNumberGenerator>
@@ -3713,15 +3719,6 @@
 
   /**
    * @brief Return true if two Bernoulli distributions have
-   *        the same parameters.
-   */
-  inline bool
-  operator==(const std::bernoulli_distribution& __d1,
-	     const std::bernoulli_distribution& __d2)
-  { return __d1.param() == __d2.param(); }
-
-  /**
-   * @brief Return true if two Bernoulli distributions have
    *        different parameters.
    */
   inline bool
@@ -3892,7 +3889,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -3904,7 +3901,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -3930,9 +3927,9 @@
         operator==(const binomial_distribution& __d1,
 		   const binomial_distribution& __d2)
 #ifdef _GLIBCXX_USE_C99_MATH_TR1
-	{ return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+	{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
 #else
-        { return __d1.param() == __d2.param(); }
+        { return __d1._M_param == __d2._M_param; }
 #endif
 
       /**
@@ -4104,7 +4101,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -4116,7 +4113,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4133,6 +4130,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two geometric distributions have
+       *        the same parameters.
+       */
+      friend bool
+      operator==(const geometric_distribution& __d1,
+		 const geometric_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4146,16 +4152,6 @@
 
   /**
    * @brief Return true if two geometric distributions have
-   *        the same parameters.
-   */
-  template<typename _IntType>
-    inline bool
-    operator==(const std::geometric_distribution<_IntType>& __d1,
-	       const std::geometric_distribution<_IntType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
-   * @brief Return true if two geometric distributions have
    *        different parameters.
    */
   template<typename _IntType>
@@ -4349,7 +4345,7 @@
       friend bool
       operator==(const negative_binomial_distribution& __d1,
 		 const negative_binomial_distribution& __d2)
-      { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
 
       /**
        * @brief Inserts a %negative_binomial_distribution random
@@ -4529,7 +4525,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -4541,7 +4537,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4567,9 +4563,9 @@
       operator==(const poisson_distribution& __d1,
 		 const poisson_distribution& __d2)
 #ifdef _GLIBCXX_USE_C99_MATH_TR1
-      { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
+      { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
 #else
-      { return __d1.param() == __d2.param(); }
+      { return __d1._M_param == __d2._M_param; }
 #endif
 
       /**
@@ -4739,7 +4735,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-        { return this->operator()(__urng, this->param()); }
+        { return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -4756,7 +4752,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4773,6 +4769,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two exponential distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const exponential_distribution& __d1,
+		 const exponential_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4785,16 +4790,6 @@
     };
 
   /**
-   * @brief Return true if two exponential distributions have the same
-   *        parameters.
-   */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::exponential_distribution<_RealType>& __d1,
-	       const std::exponential_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
    * @brief Return true if two exponential distributions have different
    *        parameters.
    */
@@ -4948,7 +4943,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -4960,7 +4955,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4977,6 +4972,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two Weibull distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const weibull_distribution& __d1,
+		 const weibull_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -4989,16 +4993,6 @@
     };
 
    /**
-    * @brief Return true if two Weibull distributions have the same
-    *        parameters.
-    */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::weibull_distribution<_RealType>& __d1,
-	       const std::weibull_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-   /**
     * @brief Return true if two Weibull distributions have different
     *        parameters.
     */
@@ -5152,7 +5146,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -5164,7 +5158,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -5181,6 +5175,15 @@
 		   const param_type& __p)
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
+      /**
+       * @brief Return true if two extreme value distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const extreme_value_distribution& __d1,
+		 const extreme_value_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
     private:
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -5193,16 +5196,6 @@
     };
 
   /**
-    * @brief Return true if two extreme value distributions have the same
-    *        parameters.
-   */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::extreme_value_distribution<_RealType>& __d1,
-	       const std::extreme_value_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
     * @brief Return true if two extreme value distributions have different
     *        parameters.
    */
@@ -5382,7 +5375,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -5394,7 +5387,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -5412,6 +5405,15 @@
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
       /**
+       * @brief Return true if two discrete distributions have the same
+       *        parameters.
+       */
+      friend bool
+      operator==(const discrete_distribution& __d1,
+		 const discrete_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
        * @brief Inserts a %discrete_distribution random number distribution
        * @p __x into the output stream @p __os.
        *
@@ -5454,16 +5456,6 @@
     };
 
   /**
-    * @brief Return true if two discrete distributions have the same
-    *        parameters.
-    */
-  template<typename _IntType>
-    inline bool
-    operator==(const std::discrete_distribution<_IntType>& __d1,
-	       const std::discrete_distribution<_IntType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
     * @brief Return true if two discrete distributions have different
     *        parameters.
     */
@@ -5649,7 +5641,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -5661,7 +5653,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -5679,6 +5671,15 @@
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
       /**
+       * @brief Return true if two piecewise constant distributions have the
+       *        same parameters.
+       */
+      friend bool
+      operator==(const piecewise_constant_distribution& __d1,
+		 const piecewise_constant_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
        * @brief Inserts a %piecewise_constan_distribution random
        *        number distribution @p __x into the output stream @p __os.
        *
@@ -5722,16 +5723,6 @@
     };
 
   /**
-    * @brief Return true if two piecewise constant distributions have the
-    *        same parameters.
-   */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::piecewise_constant_distribution<_RealType>& __d1,
-	       const std::piecewise_constant_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
     * @brief Return true if two piecewise constant distributions have 
     *        different parameters.
    */
@@ -5920,7 +5911,7 @@
       template<typename _UniformRandomNumberGenerator>
 	result_type
 	operator()(_UniformRandomNumberGenerator& __urng)
-	{ return this->operator()(__urng, this->param()); }
+	{ return this->operator()(__urng, _M_param); }
 
       template<typename _UniformRandomNumberGenerator>
 	result_type
@@ -5932,7 +5923,7 @@
 	void
 	__generate(_ForwardIterator __f, _ForwardIterator __t,
 		   _UniformRandomNumberGenerator& __urng)
-	{ this->__generate(__f, __t, __urng, this->param()); }
+	{ this->__generate(__f, __t, __urng, _M_param); }
 
       template<typename _ForwardIterator,
 	       typename _UniformRandomNumberGenerator>
@@ -5950,6 +5941,15 @@
 	{ this->__generate_impl(__f, __t, __urng, __p); }
 
       /**
+       * @brief Return true if two piecewise linear distributions have the
+       *        same parameters.
+       */
+      friend bool
+      operator==(const piecewise_linear_distribution& __d1,
+		 const piecewise_linear_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+      /**
        * @brief Inserts a %piecewise_linear_distribution random number
        *        distribution @p __x into the output stream @p __os.
        *
@@ -5993,16 +5993,6 @@
     };
 
   /**
-    * @brief Return true if two piecewise linear distributions have the
-    *        same parameters.
-   */
-  template<typename _RealType>
-    inline bool
-    operator==(const std::piecewise_linear_distribution<_RealType>& __d1,
-	       const std::piecewise_linear_distribution<_RealType>& __d2)
-    { return __d1.param() == __d2.param(); }
-
-  /**
     * @brief Return true if two piecewise linear distributions have
     *        different parameters.
    */


More information about the Libstdc++ mailing list