<algorithm> transform modification

[Steffen Brinkmann]

Hi!

I tried to modify the transform algorithm in a way that it doesn't
take iterators, but a reference to a container class and a value,
because Mostly I need to do an operation of a container and a single
number (e.g. multiply all the values in a vector by 3 or so).
So, this is my intent:

#ifndef ALGORITHM_EXT_HH
#define ALGORITHM_EXT_HH

#include<iterator>

namespace std
{
template<typename _Tp, template<typename> class _Container,
typename _Tpval, typename _BinaryOperation>
_Container<_Tp>&
transform(_Container<_Tp>& __cont, const _Tpval& __val,
_BinaryOperation __binary_op)
{
_Container<_Tp>::iterator __iter=__cont.begin();
_Container<_Tp>::iterator __end=__cont.end();
for ( ; __iter != __end; ++__iter)
*__iter = __binary_op(*__iter, __val);
return __cont;
}

} //namespace std

#endif //ALGORITHM_EXT_HH

The error message I get from g++ (GCC) 3.3 20030226 (prerelease) (SuSE
Linux) is:
linux@earth:~/> g++ mod2pnm.cc -o mod2pnm
In file included from mod2pnm.cc:16:
algorithm_ext.hh: In function `_Container<_Tp>&
std::transform(_Container<_Tp>&, const _Tpval&, _BinaryOperation)':
algorithm_ext.hh:32: error: parse error before `=' token
algorithm_ext.hh:33: error: parse error before `=' token
algorithm_ext.hh: In function `_Container<_Tp>&
std::transform(_Container<_Tp>&, const _Tpval&, _BinaryOperation)
[with _Tp
= double, _Container = std::vector, _Tpval = double,
_BinaryOperation =
std::minus<double>]':
mod2pnm.cc:144: instantiated from here
algorithm_ext.hh:34: error: `__end' undeclared (first use this
function)
algorithm_ext.hh:34: error: (Each undeclared identifier is reported
only once
for each function it appears in.)
algorithm_ext.hh:34: error: `__iter' undeclared (first use this
function)
Any ideas, what's wrong? I tried all night long!

Thanks, Steffen

[WW]

Steffen Brinkmann wrote:

#ifndef ALGORITHM_EXT_HH
#define ALGORITHM_EXT_HH

#include<iterator>

namespace std
{
You are not allowed to place anything into the std namespace!
template<typename _Tp, template<typename> class _Container,
Standard container templates take many more arguments.
typename _Tpval, typename _BinaryOperation>
_Container<_Tp>&
transform(_Container<_Tp>& __cont, const _Tpval& __val,
_BinaryOperation __binary_op)
{
_Container<_Tp>::iterator __iter=__cont.begin(); typename _Container<_Tp>::iterator __iter=__cont.begin();
_Container<_Tp>::iterator __end=__cont.end(); Ditto
for ( ; __iter != __end; ++__iter)
*__iter = __binary_op(*__iter, __val);
return __cont;
}

} //namespace std

#endif //ALGORITHM_EXT_HH

The error message I get from g++ (GCC) 3.3 20030226 (prerelease) (SuSE
Linux) is:

[SNIP]

Seems that 3.3 has two phase name lookup implemented or at least it refuses
to guess what is a type anymore.

--
WW aka Attila

[Howard Hinnant]

Steffen Brinkmann wrote:

I tried to modify the transform algorithm in a way that it doesn't
take iterators, but a reference to a container class and a value,
because Mostly I need to do an operation of a container and a single
number (e.g. multiply all the values in a vector by 3 or so).

In addition to WW's good comments, I thought I might add:

You might try out std::bind2nd in <functional> and stick with the
std::transform:

std::transform(v.begin(), v.end(), v.begin(),
std::bind2nd(std::multiplies<int>(), 3));

If you get into more complicated operations, boost::bind might provide
an answer ( www.boost.org ). boost::bind may eventually be
standardized. It has been voted into the first library technical report
which indicates an official interest in this library. The above
transform translates into bind with:

std::transform(v.begin(), v.end(), v.begin(),
boost::bind(std::multiplies<int>(), _1, 3));

-Howard

[David B. Held]

"WW" <wo***@freemail.hu> wrote in message
news:bk**********@phys-news1.kolumbus.fi...

[...]
You are not allowed to place anything into the std
namespace!
[...]

Except specializations of std::less<>, and perhaps a few other
things.

Dave

[Jerry Coffin]

In article <bk**********@phys-news1.kolumbus.fi>, wo***@freemail.hu
says...

[ ... ]

You are not allowed to place anything into the std namespace!

Not so -- you are specifically allowed to add (partial or complete)
specializations of standard library templates to namespace std. See $
17.4.3.1/1 for the exact requirements.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[WW]

David B. Held wrote:

"WW" <wo***@freemail.hu> wrote in message
news:bk**********@phys-news1.kolumbus.fi...

[...]
You are not allowed to place anything into the std
namespace!
[...]

Except specializations of std::less<>, and perhaps a few other
things.

Yeah. But they have to be specializations, not new things. And I prefer to
mentioned them for those, who know they can ask this question. :-)

--
WW aka Attila

[WW]

Jerry Coffin wrote:

In article <bk**********@phys-news1.kolumbus.fi>, wo***@freemail.hu
says...

[ ... ]

You are not allowed to place anything into the std namespace!

Not so -- you are specifically allowed to add (partial or complete)
specializations of standard library templates to namespace std. See $
17.4.3.1/1 for the exact requirements.

You are not placing them into the standard namespace. They are there and
you are allowed to specialize them. I prefer to put it this way because I
have met people (hearing there is exception) kept putting declarations of
new things there.

--
WW aka Attila

[Rob Williscroft]

WW wrote in news:bk**********@phys-news1.kolumbus.fi:

David B. Held wrote:

"WW" <wo***@freemail.hu> wrote in message
news:bk**********@phys-news1.kolumbus.fi...

[...]
You are not allowed to place anything into the std
namespace!
[...]

Except specializations of std::less<>, and perhaps a few other
things.

Yeah. But they have to be specializations, not new things. And I
prefer to mentioned them for those, who know they can ask this
question. :-)

IIUC you can specialize *any* template in namespace std aslong as
the specialization is dependant an a UDT not defined in namespace std.
I.e. this should be Ok:

class myclass {};
namespace std
{
template < typename Alloc >
class vector< myclass, Alloc >
{
};
}

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[WW]

Rob Williscroft wrote:
[SNIP]

IIUC you can specialize *any* template in namespace std aslong as
the specialization is dependant an a UDT not defined in namespace std.
I.e. this should be Ok:

class myclass {};
namespace std
{
template < typename Alloc >
class vector< myclass, Alloc >
{
};
}

Chapter and verse?

--
WW aka Attila

[Rob Williscroft]

WW wrote in news:bk**********@phys-news1.kolumbus.fi:

Rob Williscroft wrote:
[SNIP]

IIUC you can specialize *any* template in namespace std aslong as
the specialization is dependant an a UDT not defined in namespace std.
I.e. this should be Ok:

class myclass {};
namespace std
{
template < typename Alloc >
class vector< myclass, Alloc >
{
};
}

Chapter and verse?

17.4.3.1/1 - but I missed "... results in undefined ... and unless the
specialization meets the standard library requirements for the original
...." so my example wouldn't be Ok (that "IIUC" wasn't wasted after all).

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[WW]

Rob Williscroft wrote:
[SNIP]

17.4.3.1/1 - but I missed "... results in undefined ... and unless the
specialization meets the standard library requirements for the
original ..." so my example wouldn't be Ok (that "IIUC" wasn't wasted
after all).

That's what I thought. :-)

--
WW aka Attila

[Steffen Brinkmann]

Jerry Coffin <jc*****@taeus.com> wrote in message news:<MP************************@news.clspco.adelp hia.net>...

See $ 17.4.3.1/1 for the exact requirements.

Where do I find that?

Steffen

[Steffen Brinkmann]

"WW" <wo***@freemail.hu> wrote in message news:<bk**********@phys-news1.kolumbus.fi>...

template<typename _Tp, template<typename> class _Container,
Standard container templates take many more arguments.

I copied that method from Bruce Eckel's "Thinking in C++". An dit
works... Do you mean an explicit Reference?

_Container<_Tp>::iterator __iter=__cont.begin();

typename _Container<_Tp>::iterator __iter=__cont.begin();

THANKSALOT! That was it! typical case of blindness after hours of
nightly programming!

Seems that 3.3 has two phase name lookup implemented or at least it refuses
to guess what is a type anymore.

Why?

Thanks again, Steffen

[Steffen Brinkmann]

Howard Hinnant <hi*****@metrowerks.com> wrote in message news:<hi***************************@syrcnyrdrs-02-ge0.nyroc.rr.com>...

You might try out std::bind2nd in <functional> and stick with the
std::transform:

std::transform(v.begin(), v.end(), v.begin(),
std::bind2nd(std::multiplies<int>(), 3));

That was my first attempt and it worked fine. but I like
short-to-write function calls like:

std::transform(v,value,std::multiplies<int>());
If you get into more complicated operations, boost::bind might provide
an answer ( www.boost.org ). boost::bind may eventually be
standardized. It has been voted into the first library technical report
which indicates an official interest in this library. The above
transform translates into bind with:

std::transform(v.begin(), v.end(), v.begin(),
boost::bind(std::multiplies<int>(), _1, 3));

Aha, interesting site, thank you!

Steffen

[Fraser Ross]

> You might try out std::bind2nd in <functional> and stick with the

std::transform:

std::transform(v.begin(), v.end(), v.begin(),
std::bind2nd(std::multiplies<int>(), 3));

Is there a reason for not using for_each? I have been wondering if for_each
is faster.

Fraser.
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.520 / Virus Database: 318 - Release Date: 18/09/2003

[Jerry Coffin]

In article <f9**************************@posting.google.com >,
s.***@web.de says...

Jerry Coffin <jc*****@taeus.com> wrote in message news:<MP************************@news.clspco.adelp hia.net>...

See $ 17.4.3.1/1 for the exact requirements.

Where do I find that?

That's section 17.4.3.1, paragraph 1, of the C++ standard. If you don't
have a copy, you can get one as a PDF file for $18US from
webstore.ansi.org (this requires a credit or debit card they'll accept).

The DIN only seems to sell the paper version, at a much less attractive
price (242,70 Euros). You can also get it direct from the ISO (in
either PDF or paper format) for 364 CHF, which is roughly typical for a
paper copy, but clearly pretty high for a PDF.

Various other national bodies sell it as well, but I don't know of any
that sell the PDF for less than ANSI does. If you decided to get the
paper version, shipping costs would probably favor buying locally.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Howard Hinnant]

In article <3f******@news.greennet.net>,
"Fraser Ross" <fraserATmembers.v21.co.unitedkingdom> wrote:

You might try out std::bind2nd in <functional> and stick with the
std::transform:

std::transform(v.begin(), v.end(), v.begin(),
std::bind2nd(std::multiplies<int>(), 3));

Is there a reason for not using for_each? I have been wondering if for_each
is faster.

I think it would be a matter of convenience rather than performance.
for_each could certainly be used here. But the use of for_each looks
more complicated to me than does transform.

On the inside transform will do something like:

*target = op(*source);

whereas for_each will do something like:

op(*source);

In our example, we're wanting to do:

*target = *target * 3;

or maybe:

*target *= 3;

So to use for_each you have to cook up a functor that takes a single
argument and performs the desired operation (both times and assign, or
the combined *=). There is no std::multiply_assign, but you could roll
your own:

template <class T, class U = T>
struct multiply_assign
: public std::binary_function<T, U, T>
{
T& operator()(T& t, const U& u) const
{return t *= u;}
};

Then you could use this with for_each and bind2nd like:

std::for_each(v.begin(), v.end(),
std::bind2nd(multiply_assign<int>(), 3));

I would expect this example to have the same performance as the
transform version, but I have not tested that expectation.

-Howard

[Fraser Ross]

transform might be as fast if return value optimisation is used. I would
prefer another algorithm for when the output iterator is the same as an
input iterator and two ranges are used. That isn't the situation the OP
has. e.g.

template <class ForwardIterator, class InputIterator, class BinaryOperation>
BinaryOperation transform_each (ForwardIterator first1, InputIterator last1,
InputIterator first2, BinaryOperation binary_op) {
while (first1 != last1) {
binary_op(*first1, *first2);
++first1, ++first2;
}
return binary_op;
}
Fraser.
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.520 / Virus Database: 318 - Release Date: 18/09/2003

[Steffen Brinkmann]

Sorry, pressed the wrong key.

Is there a reason for not using for_each?

As I said, I'd have to write sth like

void f(double val){ val+=2.;}

and then call

for_each(v.begin(),v.end(),f());

What, if it is noct 2. but a value that is calculated at runtime?

Steffen

[red floyd]

Steffen Brinkmann wrote:

Sorry, pressed the wrong key.

Is there a reason for not using for_each?

As I said, I'd have to write sth like

void f(double val){ val+=2.;}

and then call

for_each(v.begin(),v.end(),f());

What, if it is noct 2. but a value that is calculated at runtime?

Steffen

use a functor... There's probably a standard one that I can't remember at this time, but here's one,
and I realize I may have the syntax/semantics of for_each() slightly messed up. Please have pity, gurus!

struct add_value {
double val;
add_value (val_) : val(val_) { }
double operator()(double& d) { return d += val; }
}

then you can call:

for_each(v.begin(), v.end(), add_value(some_calculated_value_here));

[Steffen Brinkmann]

Hi!

Thank you all for your postings and learned a lot.
My solution is to use bind2nd(..) and only the stl without specialisation.

Thanks again

I'm out of here, Steffen