From acdfd3103affaa1401e500c094b702da41a2a918 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <mail@ranocha.de>
Date: Thu, 30 Sep 2021 16:09:51 +0200
Subject: [PATCH 1/3] implement fallback conj to fix dot

---
 src/numerics.jl           | 11 ++++++++---
 test/test-dense-matrix.jl |  7 +++++--
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/numerics.jl b/src/numerics.jl
index dad9bf2..a1717ca 100644
--- a/src/numerics.jl
+++ b/src/numerics.jl
@@ -151,9 +151,9 @@ function N(b::BasicType)
     out = evalf(b)
     imag(out) == Basic(0.0) ? real(out) : out
 end
-        
 
-##  Conversions SymEngine -> Julia 
+
+##  Conversions SymEngine -> Julia
 function as_numer_denom(x::Basic)
     a, b = Basic(), Basic()
     ccall((:basic_as_numer_denom, libsymengine), Nothing, (Ref{Basic}, Ref{Basic}, Ref{Basic}), a, b, x)
@@ -175,6 +175,11 @@ imag(x::BasicType{Val{:RealMPFR}}) = Basic(0)
 imag(x::BasicType{Val{:Rational}}) = Basic(0)
 imag(x::SymEngine.BasicType) = throw(InexactError())
 
+# Because of the definitions above, `real(x) == x` for `x::Basic`
+# such as `x = symbols("x")`. Thus, it is consistent to define the
+# fallback
+Base.conj(x::Basic) = x
+
 ## define convert(T, x) methods leveraging N()
 convert(::Type{Float64}, x::Basic)           = convert(Float64, N(evalf(x, 53, true)))
 convert(::Type{BigFloat}, x::Basic)          = convert(BigFloat, N(evalf(x, precision(BigFloat), true)))
@@ -203,7 +208,7 @@ isless(x::Basic, y::Basic) = isless(N(x), N(y))
 
 
 ## These should have support in symengine-wrapper, but currently don't
-trunc(x::Basic, args...) = Basic(trunc(N(x), args...))  
+trunc(x::Basic, args...) = Basic(trunc(N(x), args...))
 trunc(::Type{T},x::Basic, args...) where {T <: Integer} = convert(T, trunc(x,args...))
 
 ceil(x::Basic) = Basic(ceil(N(x)))
diff --git a/test/test-dense-matrix.jl b/test/test-dense-matrix.jl
index 5bd7fbd..1fc9a7e 100644
--- a/test/test-dense-matrix.jl
+++ b/test/test-dense-matrix.jl
@@ -1,9 +1,9 @@
 using Test
 using SymEngine
-import LinearAlgebra: lu, det, zeros
+import LinearAlgebra: lu, det, zeros, dot
 CDenseMatrix = SymEngine.CDenseMatrix
 
-@vars x
+@vars x y
 
 # constructors
 A = [x 1 2; 3 x 4; 5 6 x]
@@ -44,3 +44,6 @@ out = M \ b
 
 @test SymEngine.dense_matrix_eye(2,2,0) == Basic[1 0; 0 1]
 
+# dot product
+@test dot(x, x) == x^2
+@test dot([1, x, 0], [y, -2, 1]) == y - 2x

From 48ee04e6f287b8de8c239f83843e41a0b43869f8 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <mail@ranocha.de>
Date: Fri, 1 Oct 2021 08:47:18 +0200
Subject: [PATCH 2/3] fix conj

---
 src/numerics.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/numerics.jl b/src/numerics.jl
index a1717ca..422e341 100644
--- a/src/numerics.jl
+++ b/src/numerics.jl
@@ -178,7 +178,7 @@ imag(x::SymEngine.BasicType) = throw(InexactError())
 # Because of the definitions above, `real(x) == x` for `x::Basic`
 # such as `x = symbols("x")`. Thus, it is consistent to define the
 # fallback
-Base.conj(x::Basic) = x
+Base.conj(x::Basic) = 2 * real(x) - x
 
 ## define convert(T, x) methods leveraging N()
 convert(::Type{Float64}, x::Basic)           = convert(Float64, N(evalf(x, 53, true)))

From 3ac2d66eb3591a1633f381de0f8070e2c87bdd08 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <mail@ranocha.de>
Date: Fri, 1 Oct 2021 08:55:25 +0200
Subject: [PATCH 3/3] add some basic tests for complex numbers

---
 test/runtests.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/runtests.jl b/test/runtests.jl
index 975a775..3b8344d 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -246,3 +246,12 @@ end
 @test_throws DomainError sin(zoo)
 @test_throws DomainError sin(oo)
 @test_throws DomainError subs(sin(log(y - y/x)), x => 1)
+
+# Some basic checks for complex numbers
+@testset "Complex numbers" begin
+    for T in (Int, Float64, BigFloat)
+        j = one(T) * IM
+        @test j == imag(j) * IM
+        @test conj(j) == -j
+    end
+end