adding vectors

[Andy Leszczynski]

Hi,

Short question: why (1,"abc",0.3)+(2,"def",10.2) != (3,"abcdef",10.5)?

How to elegantly achieve (3,"abcdef",10.5) as a result of addition ...
Andy

[Paul Rubin]

Andy Leszczynski <ya***@nospam.leszczynscy> writes:

Short question: why (1,"abc",0.3)+(2,"def",10.2) != (3,"abcdef",10.5)?
How to elegantly achieve (3,"abcdef",10.5) as a result of addition ...

tuple([(a+b) for a,b in zip((1,"abc",0.3),(2,"def",10.2))])

[Mike Meyer]

Paul Rubin <http://ph****@NOSPAM.invalid> writes:

Andy Leszczynski <ya***@nospam.leszczynscy> writes:

Short question: why (1,"abc",0.3)+(2,"def",10.2) != (3,"abcdef",10.5)?
How to elegantly achieve (3,"abcdef",10.5) as a result of addition ...

tuple([(a+b) for a,b in zip((1,"abc",0.3),(2,"def",10.2))])

map(operator.add, (1, "abc", 0.3), (2, "def", 10.2))

[3, 'abcdef', 10.5]

Not having to do the zip is win. operator.add is a lose. I'm not sure
either is what I'd call elegant.

As for the "why" question, it's because the current behavior is more
generally useful. You can always concatenate two lists to get a longer
lists. The elements in a list don't have to support add, so using "+"
to denote elementwise addition is sorta pointless.

<mike
--
Mike Meyer <mw*@mired.org> http://www.mired.org/home/mwm/
Independent WWW/Perforce/FreeBSD/Unix consultant, email for more information.

[Alex Martelli]

Andy Leszczynski <ya***@nospam.leszczynscy> wrote:

Hi,

Short question: why (1,"abc",0.3)+(2,"def",10.2) != (3,"abcdef",10.5)?
Because '+' applied to sequences means to concatenate them -- a more
frequent need than "element by element addition" (which I notice you
would NOT want to apply to strings, only to sequences for which it
happens to be convenient for your specific app...!-).
How to elegantly achieve (3,"abcdef",10.5) as a result of addition ...

If you mean "by using operator + on tuples", no way. If you're not hung
up on syntax, e.g.

def elemadd(t1, t2):
return tuple(i1+i2 for i1, i2 in zip(t1, t2))

or any of several other ways.
Alex

[Paul Rubin]

Mike Meyer <mw*@mired.org> writes:

map(operator.add, (1, "abc", 0.3), (2, "def", 10.2))

[3, 'abcdef', 10.5]

Not having to do the zip is win. operator.add is a lose. I'm not sure
either is what I'd call elegant.

Yeah, I didn't bother checking whether you could pass dyadic functions
to map. Given that you can, I see nothing wrong with lambda x,y: x+y
instead of operator.add, but that's just me.

[Terry Hancock]

On Mon, 19 Dec 2005 22:06:31 -0500
Andy Leszczynski <ya***@nospam.leszczynscy> wrote:

Short question: why (1,"abc",0.3)+(2,"def",10.2) !=
(3,"abcdef",10.5)?

How to elegantly achieve (3,"abcdef",10.5) as a result of
addition ...

(a,b,c) is a "tuple", not a "vector".

IMHO, the "elegant" thing to do is to define a vector class
and use it. For convenience, allow a tuple initializer:

V = Vector
a = V(1,"abc",0.3) + V(2,"def",10.2)

Of course, the class "Vector" will have to define math
operators appropriately. Note that "%" has the correct
precedence to sub for cross-product, and sort of looks like
an X if you squint hard enough ;-).

--
Terry Hancock (ha*****@AnansiSpaceworks.com)
Anansi Spaceworks http://www.AnansiSpaceworks.com