On Tue, Aug 18, 2009 at 9:31 AM, Maciej Fijalkowski<fij...@gmail.com> wrote:
>
> On Tue, Aug 18, 2009 at 1:12 AM, Fredrik
> Johansson<fredrik.johans...@gmail.com> wrote:
>>
>> On Tue, Aug 18, 2009 at 8:50 AM, Maciej Fijalkowski<fij...@gmail.com> wrote:
>>>
>>> Hi.
>>>
>>>>
>>>> I think SymPy is an excellent benchmark target. The nature of SymPy
>>>> (or any computer algebra system) is such that any high-level operation
>>>> will exercise most parts of the system. For example
>>>> "integrate(x**3*exp(x)*sin(x), x)" performs ~4 million function calls
>>>> to some 200 functions all over SymPy, and it's a calculation that
>>>> you'd use SymPy for in practice, so it would be a good real-world test
>>>> case.
>>>>
>>>> Also, mpmath might be a good target (mpmath is a subpackage of SymPy).
>>>> There are some microbenchmarks at [1] although I could come up with
>>>> some slightly more complex "real world" calculation if you are
>>>> interested. Mpmath heavily depends on long integer performance in
>>>> particular, but if you use low precision, it will exercise general
>>>> Python performance. For myself, I would be interested in whether
>>>> PyPy's new JIT can beat psyco, which all around makes mpmath ~2x
>>>> faster on top of CPython.
>>>
>>> Long integer performance is not *exactly* on top of my list of stuff to
>>> look to.
>>> About PyPy JIT beating psyco, yes, but not exactly right now :-)
>>>
>>> I was also wondering what *does not* exercise most of the system and yet
>>> still makes some sort of sense.
>>
>> By wondering, do you mean that you are looking for this (i.e. you are
>> looking for a benchmark that invokes a relatively small amount of
>> code), or are you implicating me as not making sense? :-)
>>
>
> Heh :-) I suppose I'm looking for a benchmark that invokes relatively
> small amount
> of code, but still a bit more than a single loop.
>
> Cheers,
> fijal
A very simple, and equally important, benchmark would be the basic
performance of the Integer and Rational classes.
Integer is just a wrapper for Python ints with some extra type
checking; a JIT should theoretically be able to make
def foo(N):
while N > 0:
N -= 1
run as fast if called with foo(1000000) as with foo(sympy.Integer(1000000)).
Fredrik
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"sympy" group.
To post to this group, send email to sympy@googlegroups.com
To unsubscribe from this group, send email to sympy+unsubscr...@googlegroups.com
For more options, visit this group at http://groups.google.com/group/sympy?hl=en
-~----------~----~----~----~------~----~------~--~---
