On 26 Nov, 12:09, "Ondrej Certik" <[EMAIL PROTECTED]> wrote:
> > I have tried SyFi on several real examples like the Bidomain
> > equations, Navier-Stokes etc.
> > But I only use SyFi for generating the C++ code for the finite
> > elements, element matrices etc.
> > The generated code is usually very fast, orders of magnitude faster
> > than traditional quadrature.
> > Its code and efficiency is similar to FFC. Assembly is typically done
> > in Dolfin/PyCC and solving
> > the linear systems is done in Hypre/Trilinos.
>
> Assembly is enough for me, I need to solve the eigenproblem anyway, so
> I use blzpack/arpack/primme for that.
> I'll try it, this sounds pretty exciting.
>
> > Many of the Fenics projects have been in a state of flux for the last
> > year. But this
> > is improving. The future plan of SyFi is to come up with a nice user
> > interface/language such
> > that SyFi will work as a compiler translating high-level finite
> > element python code
> > to efficient low-level C++ code.
>
> > The reason why I am looking at Sympy is that although I am fairly
> > happy with GiNaC, it has its issues.
>
> Could you be more specific what issues GiNaC has? The only problem
> with ginac that I know of is that it is very difficult to create new
> functions,
> but as far as I know, SyFi just needs polynomials.
There are at least two issues, the license (it could be a problem for
the institute
I work at in the long run).
The more serious issue (now) is that GiNaC expands everything.
For instance, I'd like the derivative with respect to x of a function
f(x)
to be stored as an object Derivative(f,x), much like GiNaCs integrals
before eval_integ.
Or when doing G(x) = N(x)*M(x), G is not the expanded product of N and
M, but keeps
N and M.
I guess SymPy and GiNaC behave similarly in these matters, but I guess
it is easier to implement
such features in SymPy.
>
> > Still, I think I'd prefer Sympy (except the efficiency).
>
> > Can sympy generate C++ code ?
>
> Not yet, but this is fairly easy to do. We can generate a Python code:
>
> In [1]: e = sin(x)**4/y**(-2)
>
> In [2]: e
> Out[2]:
> 2 4
> y *sin (x)
>
> In [3]: Basic.set_repr_level(0)
> Out[3]: 2
>
> In [4]: e
> Out[4]: Mul(Pow(Symbol('y'), Integer(2)), Pow(sin(Symbol('x')), Integer(4)))
>
> So we can generate C++ code as well. But of course only a subset of
> sympy features can be exported to C++. Mainly just an expression and a
> way to substitute to that
> expression. So the above should translate to something like this:
>
> float x;
> float y;
> e = pow(sin(x), 4)*pow(y,2);
>
> is that correct? If you could give me more info what exactly you need,
> I'll implement that.
>
This is what I need, although I'd like double instead of float.
> > > From profiling your code, it appears that nearly all the time is spent
> > > in integrate().
> > > This shows quite clearly that we need to optimize the integration code for
> > > polynomials.
>
> > > Fredrik
>
> > Ok thanks, is this easy to do ?
>
> I think it should be fairly easy, that's why I wrote SymPy, so that
> those things are easy. We just need to go to:
>
> http://hg.sympy.org/sympy/file/c8da4f2b2324/sympy/integrals/integrals.py
>
> line 122, and we use a general (slow) algorithm to integrate a lot of
> functions. So we just check, if we got a polynomial, extract the
> coefficients and integrate it. We can use functions from:
>
> http://hg.sympy.org/sympy/file/132066377866/sympy/polynomials/base.py
>
> There is a Polynomial class in there, so my bet is just to implement
> .integrate() in that class, to be as efficient as possible and than
> just fix ingetrals.py, to try to convert to polynomial if it is a
> polynomial.
>
> I'll try it in the evening, if it speeds things up.
>
> Ondrej
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"sympy" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/sympy?hl=en
-~----------~----~----~----~------~----~------~--~---
