Convert methods for other common complex types available

These methods were written in order to avoid having to use real()
or imag(), as they create a new MPFRFloat object.

base/mpc.jl

@@ -110,10 +110,34 @@ convert(::Type{MPCComplex}, x::Complex) = MPCComplex(x)
 convert{N,P}(::Type{MPCComplex{N,P}}, x::ImaginaryUnit) = MPCComplex(x)
 convert(::Type{MPCComplex}, x::ImaginaryUnit) = MPCComplex(x)
 
-convert(::Type{Float64}, x::MPCComplex) = ccall((:mpc_get_d,:libmpc), Float64, (Ptr{mpc_struct},), &(x.mpc))
-convert(::Type{Float32}, x::MPCComplex) = ccall((:mpc_get_flt,:libmpc), Float32, (Ptr{mpc_struct},), &(x.mpc))
-#convert(::Type{FloatingPoint}, x::BigInt) = MPCComplex(x)
-
+function convert(::Type{Complex{Float64}}, x::MPCComplex)
+    return complex(
+        ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{Void},), &(realref(x))),
+        ccall((:mpfr_get_d,:libmpfr), Float64, (Ptr{Void},), &(imagref(x))))
+end
+function convert(::Type{Complex{Float32}}, x::MPCComplex)
+    return complex(
+        ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{Void},), &(realref(x))),
+        ccall((:mpfr_get_flt,:libmpfr), Float32, (Ptr{Void},), &(imagref(x))))
+end
+function convert(::Type{Complex{Int64}}, x::MPCComplex)
+    if realint(x) && imagint(x)
+        return complex(
+            ccall((:mpfr_get_si,:libmpfr), Int64, (Ptr{Void}, Int32), &(realref(x)), ROUNDING_MODE[end]),
+            ccall((:mpfr_get_si,:libmpfr), Int64, (Ptr{Void}, Int32), &(imagref(x)), ROUNDING_MODE[end]))
+    else
+        throw(InexactError())
+    end
+end
+function convert(::Type{Complex{Int32}}, x::MPCComplex)
+    if realint(x) && imagint(x)
+        return complex(
+            int32(ccall((:mpfr_get_si,:libmpfr), Int64, (Ptr{Void}, Int32), &(realref(x)), ROUNDING_MODE[end])),
+            int32(ccall((:mpfr_get_si,:libmpfr), Int64, (Ptr{Void}, Int32), &(imagref(x)), ROUNDING_MODE[end])))
+    else
+        throw(InexactError())
+    end
+end
 promote_rule{T<:Real,N,P}(::Type{MPCComplex{N,P}}, ::Type{T}) = MPCComplex{N,P}
 promote_rule{T<:Real}(::Type{MPCComplex}, ::Type{T}) = MPCComplex
 promote_rule{T<:Real,N,P}(::Type{MPCComplex{N,P}}, ::Type{Complex{T}}) = MPCComplex{N,P}
@@ -267,4 +291,12 @@ string(x::MPCComplex) = "$(string(real(x))) + $(string(imag(x)))im"
 show(io::IO, b::MPCComplex) = print(io, string(b) * " with $(get_precision(b)) bits of precision")
 showcompact(io::IO, b::MPCComplex) = print(io, string(b))
 
+# Internal functions
+# Unsafe for general use
+realref(x::MPCComplex) = MPFR.mpfr_struct(x.mpc.reprec, x.mpc.resign, x.mpc.reexp, x.mpc.red)
+imagref(x::MPCComplex) = MPFR.mpfr_struct(x.mpc.imprec, x.mpc.imsign, x.mpc.imexp, x.mpc.imd)
+realint(x::MPCComplex) = ccall((:mpfr_integer_p, :libmpfr), Int32, (Ptr{Void},), &(realref(x))) != 0
+imagint(x::MPCComplex) = ccall((:mpfr_integer_p, :libmpfr), Int32, (Ptr{Void},), &(imagref(x))) != 0
+
+
 end #module

test/mpc.jl

@@ -53,6 +53,19 @@ y = MPCComplex(x)
 @test real(x) == real(y)
 @test imag(x) == imag(y)
 
+# conversion
+with_bigcomplex_precision(53) do
+    x = MPCComplex(12, 42)
+    @test typeof(convert(Complex{Float64}, x)) == Complex{Float64}
+    @test typeof(convert(Complex{Float32}, x)) == Complex{Float32}
+    @test typeof(convert(Complex{Int64}, x)) == Complex{Int64}
+    @test typeof(convert(Complex{Int32}, x)) == Complex{Int32}
+    @test 12. + 42.0im == convert(Complex{Float64}, x)
+    @test 12f0 + 42f0im == convert(Complex{Float32}, x)
+    @test 12 + 42im == convert(Complex{Int64}, x)
+    @test 12 + 42im == convert(Complex{Int32}, x)
+end
+
 # +
 x = MPCComplex(12,42)
 @test (x + x) == MPCComplex(24, 84)