@bollu, SymEngine internally allocates memory dynamically. Is that going to be a problem?

To make it threadsafe, add

`-DWITH_SYMENGINE_THREAD_SAFE=yes`

to cmake when building symengine if you are compiling it yourself. Ubuntu ppa package and conda package is compiled with that option
it shouldn't be, but again, I don't fully understand the interactions right now

I'll investigate further and get back to you

@isuruf are you around? I wanted some clarification with the memory contract

like, if I want to call

```

```

`CWRAPPER_OUTPUT_TYPE basic_add(basic s, const basic a, const basic b);`

`basic s`

should be allocated with `basic_new_heap`

right?
I would like to contribute to symengine. I know C++. I tried to go through the code on GitHub, but don't know exactly where to start. Can someone guide me?

@isuruf : quick question: on the Haskell side, I observe that

`x * (v - 1) != x * v - x * 1`

I'm writing a minimal test case to reproduce this

`x`

and `v`

are symbols
but is this considered a bug?

@aneesh2312 go take a look at issues tagged "easy to fix". Here is a link

if you have specific interests, please do tell!

basically,

`==`

is not mathematical equality, but structural equality
so what should I use to check mathematical equality?

there's not such function in symengine yet, though sympy has some

hm

are there element-wise multiplication functions in symengine for matrices? I don't see them

may I add them?

I

I'm trying to maintain API compatibility with haskell's "native" matrix library (hmatrix)

it uses (*) as element wise multiplication

and so on

also, what about shapes? like, auto scaling a

`1x1`

matrix to fit the shape of a differently shaped matrix? (the way `numpy`

does)
Yes, there is, in sympy.matrices.matrices. It simply applies expand to each entry.

I'm writing the FFI to Haskell

also, it appears (through the FFI) that

```
[0, 2]
[4, 6]
```

gives divide by zero on me trying to invert it though it isn't singular

I haven't tried to reproduce this in C

but, am I missing something basic?