I’m using SymPy in Julia and can’t use the chop function. As a result of my calculations I have a number like

20.663702825333246 + 2.6469779601696886e-23im

If I try to:

chop(ans)

I get this error:

MethodError: no method matching chop(::Complex{Float64})

Closest candidates are:

chop(::AbstractString) at strings/util.jl:39

Why isn’t it working, and how should I do it? (I’m working on Julia v0.5)

What do you want to do, i.e. what should `chop`

do?

As you can read from the error message, `chop`

works for strings, not numbers. Is `round`

what you are looking for?

```
julia> round(20.663702825333246 + 2.6469779601696886e-23im, 10)
20.6637028253 + 0.0im
```

From the manual:

```
round(x, digits) rounds to the specified number of digits after the decimal place (or before if negative).
```

1 Like

But `round`

isn’t defined properly for `Sym`

Objects … Not sure what the OP wants, but perhaps `round(N(x))`

or `x[:round]()`

until this is addressed.

In SymPy chop: “Chops off small real or imaginary parts, or converts numbers close to zero to exact zeros.” (http://docs.sympy.org/0.7.1/modules/mpmath/general.html) `round`

kinda does the thing, that I want, if we don’t find better solution, I will go with that.

It isn’t pretty, and I doubt it should be nicer, but you can try `SymPy.mpmath[:chop](x,tol=1e9)`

, say

It is unclear why you need a symbolic library, but if I understand you requirements correctly, it should be easy to implement in Julia:

```
numchop{T <: Real}(x::T, δ = eps(T)) = abs(x) > δ ? x : zero(T)
function numchop{T <: Real}(x::Complex{T}, δ = eps(T))
ichop = numchop(imag(x), δ)
rchop = numchop(real(x), δ)
if ichop == zero(T)
rchop
else
complex(rchop, ichop)
end
end
```

Note that of course it is not type stable.

1 Like

The `SymPy.mpmath[:chop](x,tol=1e9)`

doesn’t work, it returns a `Complex{BigFloat}`

with a bunch of zeros at the end of both the real and imaginary parts. But the `numchop`

function works well, thank you for your help!

This is pretty late, but one of the first modules I wrote is ZChop.jl I think it does what you want. It is similar to Mathematica’s Chop.

2 Likes

Try explicity wrapping the complex number with PyObject, as so `PyObject(1 + 1 im)`

before calling the python function.