These are chat archives for symengine/symengine
FindBoost.cmakeuses the location
Exprdon't have the same signature as the same of
sympy.Exprwhich might be too much work. I understand in general however symengine.py tries to provide the same features as SymPy?
Expr, but there are some things that we do differently.
symengine.series()and I want to provide for the SymPy case the functionality that calling
series(ex)as well as
symengine.series(ex)in case of univar, and call
sympy.series(ex)in all other cases. Which Python functions in symengine_wrapper.pyx do I have to write? My first guess is to write
Basic.series()because there is no
series(). Now both would have to call
sympy.series(ex)for the unhandled cases, so the
Basicmust be converted to SymPy then the call and then the result must be converted back, right?
sympy.seriesaccepts symengine objects as well, but the output would be a SymPy object, so that has to be converted to symengine.
Basic. Do I need to convert explicitly?
std::unordered_mapwhich is in Cython-0.20.2 but you require only 0.19.1 for symengine.py. I could include the PXD from the 0.20.2 Cython source, or you could raise requirements. However, even the newest standard OpenSuSE has only 0.19.2. So better keep the requirements?
symengine.pycan definitely contain cythonized stuff from sympy. But for example the basic manipulation is much faster in symengine than what I was ever able to achieve using just Cython. The same with multivariate series --- we wouldn't be able to get even close to Piranha. But yes, if Cythonizing provides some good speedup for some algorithm in sympy, we should definitely include it in symengine.py. And then later move it to symengine itself. So far our approach was to implement it directly in symengine itself in C++ and just wrap it. That way also Julia, Ruby and other wrappers can use it.
Ultimately I expect some libraries to be faster for the univariate stuff that we have so far, but as long as we are at least as fast as ginac, then we are fine.
We should find some good benchmarks for multivariate stuff. I found some examples here:
Odd Cython error:
ctypedef unordered_map[short, RCP[const Basic]] umap_short_basic "SymEngine::umap_short_basic" ^ ------------------------------------------------------------ symengine.pxd:183:44: Expected ']', found 'Basic'
Two lines later the same
RCP[const Basic] passes without problems:
ctypedef set[RCP[const_Basic], RCPBasicKeyLess] set_basic "SymEngine::set_basic"
RCP[const Basic](have it as argument to