[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

Re: [pygame] vector type: mutable or immutable



Lorenz Quack schrieb:

Gregor Lingl wrote:

...
pression without the in-place operator (as would be necessary if we go with immutable types). 
Hi Lorenz,

I'd propose not to confuse two things:
(1) use of syntax x = x + x versus x += x
(2) use of immutable versus mutable datatypes

In python you can write

 >>> a = 2
 >>> a = a + a
 >>> a
4

as well as

 >>> a += a
 >>> a
8

although the int type is immutable.
true, but as a performance test I think my approach is still valid because if you do
ok. my objection concerned also some previous postings in this thread that stated, 
that use of a+=b makes a mutable vector type necessary.

>>> a = 2
>>> a += a
I believe the interpreter internally takes the two operands (in this case a and a) adds them and then rebinds the result to a (the id changes) so effectively doing 
>>> a = a + a
exactly because a is immutable
if a were mutable the two expressions would be indeed different the += version would not create a new instance and rebind the name a to it but modify the object a is referring to, while a = a + a would again create a new object and rebind it. 
So therefore I believe that this test does make sense.
Tell me if I'm wrong somewhere.



here are the calls with the results:



[snip]
which has more than 30000 digits. Which result did you get after 10000000 executions of the statement x = x + x?
And which implementation of the long integer type did you use that is that much faster than Python's ? 

Regards,
Gregor
indeed those are valid objections. well first of all I used a self-written C extension with double as the underlying type. but the result after 1023 iterations turns into (inf, inf). this could of course invalidate the results so I modified the test:
>>> timeit.repeat("x = Vector2d(2,3); x += x", "from vector import Vector2d", repeat=5, number=10000000) 
[5.1832518577575684,
 5.1106431484222412,
 5.1510121822357178,
 5.0923140048980713,
 5.0608019828796387]
>>> timeit.repeat("x = Vector2d(2,3); x = x + x", "from vector import Vector2d", repeat=5, number=10000000) 
[6.5348029136657715,
 6.3499071598052979,
 6.4433431625366211,
 6.412431001663208,
 6.4398849010467529]
>>> timeit.repeat("x = Vector2d(2,3)", "from vector import Vector2d", repeat=5, number=10000000) 
[3.7264928817749023,
 3.6346859931945801,
 3.6241021156311035,
 3.7733709812164307,
 3.6264529228210449]
Did you use two different Vector2d classes here, one mutable and one immutable? Why do they have the same name then? Or did you merely implement the operations x+=x and x=x+x differently?
If x = x + y creates a new object x or changes x is also a matter of how it is implemented.
Moreover it is my conviction that one must not decide about which data type to use on 
the basis of a +- 50 percent difference in performance.
One more remark: At least on module of the standard library of Python has a (rather simple) 2d-Vector class implemented in pure Python, which of course has a considerably worse performance, 
by a factor of 4 approximately:
>>> timeit.repeat("x = Vec2D(2,3); x = x + x", "from turtle import Vec2D", repeat=1, number=10000000) 
[25.274672320512536]
Nevertheless one would expect a class implemented in C to run *much* faster than a pure Python solution. So I suspect that your implementation may not be sufficiently significant to serve as a criterion to 
decide that issue.

Best regards,
Gregor
.







so the numbers change but the overall result stays the same.