Thread: bind2nd problems

I'm trying to implement a standard deviation routine using templates but I hit a snag with the bind2nd operator and I just don't get it:

Code:

template<typename T> struct minus_squared
    : public std::binary_function<T, T, T> {
    T operator()(const T& t1, const T& t2) const {
      return pow(t1 - t2, 2);
    }
  };

  template<typename S, template <typename T> class Container>
    double sd(const Container<S>& ct) {
    double m = mean(ct);
    return sqrt(std::accumulate(ct.begin(), ct.end(), 0.0,
                                std::bind2nd(minus_squared<S>(), m))
                / (ct.size() - 1));
  }

I'm calling it with a vector of doubles and the error I get is:

Code:

/usr/include/c++/4.0.0/bits/stl_numeric.h: In function ‘_Tp std::accumulate(_InputIterator, _InputIterator, _Tp, _BinaryOperation) [with _InputIterator = __gnu_cxx::__normal_iterator<const double*, std::vector<double, std::allocator<double> > >, _Tp = double, _BinaryOperation = std::binder2nd<tlin::minus_squared<double> >]’:
named_matrix.h:145:   instantiated from ‘double tlin::sd(const Container<S>&) [with S = double, Container = std::vector]’
schone.cpp:14:   instantiated from here
/usr/include/c++/4.0.0/bits/stl_numeric.h:116: error: no match for call to ‘(std::binder2nd<tlin::minus_squared<double> >) (double&, const double&)’
/usr/include/c++/4.0.0/bits/stl_function.h:439: note: candidates are: typename _Operation::result_type std::binder2nd<_Operation>::operator()(const typename _Operation::first_argument_type&) const [with _Operation = tlin::minus_squared<double>]
/usr/include/c++/4.0.0/bits/stl_function.h:445: note:                 typename _Operation::result_type std::binder2nd<_Operation>::operator()(typename _Operation::first_argument_type&) const [with _Operation = tlin::minus_squared<double>]

meaning obviously that "binder2nd" is expecting only one argument but is getting two arguments. What I don't understand is why?

Code:

template<typename S, template <typename T> class Container> double sd(const Container<S>& ct)

This is almost as portable as successfully dereferencing null.

The standard containers may have more template parameters than is strictly required.

I don't think this particular attempt will work with any container. (Originally I had written "This will never work.".)

If you actually want to support any container of any numeric type you'll either have to overload on the contained type with all the standard containers, have an infinite number of generic overloads adding template parameters, or just do it right and use the iterators, traits, and algorithms provided by the STL.

Edit: I stole LL's 'add_mean_diff'--which is a truly crappy name--to write a good example.

Soma

Code:

#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>

template
<
   typename ForwardIterator
>
typename std::iterator_traits<ForwardIterator>::value_type mean
(
   const ForwardIterator first,
   const ForwardIterator last
)
{
   typedef std::iterator_traits<ForwardIterator> my_iterator_traits;
   typedef typename my_iterator_traits::value_type value_type;
   typedef typename my_iterator_traits::difference_type difference_type;
   const value_type sum_of_elements(std::accumulate(first, last, value_type()));
   const difference_type number_of_elements(std::distance(first, last));
   return(sum_of_elements / number_of_elements);
}

template
<
   typename T
>
struct add_mean_diff: std::binary_function<T, T, T>
{
   add_mean_diff
   (
      const T & f
   ):
      m(f)
   {
   }
   T operator ()
   (
      const T & p1,
      const T & p2
   ) const
   {
      T difference(p2 - m);
      return(p1 + (difference * difference));
   }
   T m;
};

template
<
   typename ForwardIterator
>
typename std::iterator_traits<ForwardIterator>::value_type standard_deviation
(
   const ForwardIterator first,
   const ForwardIterator last
)
{
   using std::sqrt;
   typedef std::iterator_traits<ForwardIterator> my_iterator_traits;
   typedef typename my_iterator_traits::value_type value_type;
   typedef typename my_iterator_traits::difference_type difference_type;
   const value_type mean_of_elements(mean(first, last));
   const difference_type number_of_elements(std::distance(first, last));
   return(sqrt(std::accumulate(first, last, value_type(), add_mean_diff<value_type>(mean_of_elements)) / number_of_elements));
}

int main()
{
   double values[] = {34, 27, 45, 55, 22, 34};
   std::cout << standard_deviation(values, values + (sizeof(values) / sizeof(*values))) << '\n';
   return(0);
}

Originally Posted by laserlight

I think the problem is that std::accumulate() is supposed to use the function object provided to "sum" the elements. What you are trying to do is to apply the function object on each element, and then accumulate the result.

Thanks. I had misunderstood how accumulate functions. Now I know better.

Originally Posted by CornedBee

One parameter to a container? No, that's just plain invalid. Every standard container has at least two parameters (data type and allocator) and the standard allows even more, as long as they have defaults. And defaults are not considered when matching templates to template template arguments.
In other words, this cannot work with any standard container, unless the compiler has a special extension for considering defaults.

I discovered this just now. My compiled fine on my Mac with gcc 4.0, but when I tried to compile it on a Linux machine with gcc 4.2.2, it popped an error message. I'll just write code for standard deviation in plain, unvarnished code.

I think he means that this kind of stuff [...] by C++ standards.

Considering it doesn't even work with the standard containers, it absolutely isn't generic enough.

It looks perfectly [...] a number of times.

Who cares? I've successfully dereferenced null. That doesn't make it standard or portable.

If you're going to [...] anything better!

I wouldn't have given it a name at all as it doesn't deserve one. I would have used my lambda utilities to write it directly inside the function. That wouldn't have been very useful for the OP though would it?

I'm curious, did you have a good reason to take a dig at me? Or was it just that you think I'm was wrong?

Soma