[bocklund]

Even though SymPy is written in Python, there are several options to go much faster. The simplest is when actually using the symbolic expression to do some calculation. For that SymPy has a `lambdify`, which can make a callable using NumPy as the backend. They also have a variety of code printers to write your expression in C/Fortran/Julia/<many others> that you can compile to be very fast.

There’s also the SymEngine project, which is a rewrite of SymPy in C++ with bindings to other languages (like Python where it is a drop-in API replacement for SymPy). It’s not finished yet, but the CAS is a lot faster and it’s lambdify can give you an internal representation or an LLVM-compiled version, both of which are much faster than SymPy in compile-time and run-time for our expressions (which are often quite large, but simple in terms of the mathematical functions used).

[tikej]

Sure, but that's numerics. What I meant by high performance symbolic computing was things integrating hundred term expression or expanding, manipulating and simplifying expressions of similar lengths or solving (diagonalising) 9x9 matrix with symbolic expressions. Unfortunately in these applications SymPy is (painfully) slow, although I haven't tried using PyPy backend for this.

Yeah, SymEngine is a great idea and it is a lot faster, but its functionality is very limited compared to SymPy. The development is slower than SymPy and I suppose its due to the fact that its in C++, which is more difficult to write after all. Therefore I don't believe it will ever catch up with SymPy features and it boils down to the two-language problem. I think Julia (with multiple dispatch, parametric type system and JIT) is a great candidate for CAS, but it's still very far behind SymPy (although the nice thing is that functionalities can be "borrowed" via PyCall until they are rewritten).

[ChrisRackauckas]

Julia's ModelingToolkit.jl is already pretty far along and has a lot of SymPy, plus extra features like parallel simplification and generation of parallel sparse functions via its form of lambify. See the first tutorial on that: https://mtk.sciml.ai/dev/tutorials/symbolic_functions/ . The equation solver is in progress right now and is moving along quite fast. The nice thing is that this will all use Julia's multithreading, since separate tree cases are mostly independent so there's a lot of parallelism that the symbolic pieces can use here.