leverage symengine_classes approach

Author: jverzani

ext/SymEngineTermInterfaceExt.jl

@@ -21,7 +21,17 @@ import TermInterface
 λ(::Val{:Csch}) = csch; λ(::Val{:Sech}) = sech; λ(::Val{:Coth}) = coth
 λ(::Val{:Asinh}) = asinh; λ(::Val{:Acosh}) = acosh; λ(::Val{:Atanh}) = atanh
 λ(::Val{:Acsch}) = acsch; λ(::Val{:Asech}) = asech; λ(::Val{:Acoth}) = acoth
-λ(::Val{:Gamma}) = gamma; λ(::Val{:Zeta}) = zeta; λ(::Val{:LambertW}) = lambertw
+λ(::Val{:ATan2}) = atan;
+λ(::Val{:Beta}) = SymEngine.SpecialFunctions.beta;
+λ(::Val{:Gamma}) = SymEngine.SpecialFunctions.gamma;
+λ(::Val{:PolyGamma}) = SymEngine.SpecialFunctions.polygamma;
+λ(::Val{:LogGamma}) = SymEngine.SpecialFunctions.loggamma;
+λ(::Val{:Erf}) = SymEngine.SpecialFunctions.erf;
+λ(::Val{:Erfc}) = SymEngine.SpecialFunctions.erfc;
+λ(::Val{:Zeta}) = SymEngine.SpecialFunctions.zeta;
+λ(::Val{:LambertW}) = SymEngine.SpecialFunctions.lambertw
+
+
 
 const julia_operations = Vector{Any}(missing, length(SymEngine.symengine_classes))
 for (i,s) ∈ enumerate(SymEngine.symengine_classes)

src/mathfuns.jl

@@ -51,19 +51,42 @@ for (meth, libnm, modu) in [
                       (:acsch,:acsch,:Base),
                       (:atanh,:atanh,:Base),
                       (:acoth,:acoth,:Base),
-                      (:gamma,:gamma,:SpecialFunctions),
                       (:log,:log,:Base),
                       (:sqrt,:sqrt,:Base),
                       (:exp,:exp,:Base),
                       (:sign, :sign, :Base),
-                      (:eta,:dirichlet_eta,:SpecialFunctions),
-                      (:zeta,:zeta,:SpecialFunctions),
+                      (:ceil, :ceiling, :Base),
+                      (:floor, :floor, :Base)
                       ]
     eval(:(import $modu.$meth))
     IMPLEMENT_ONE_ARG_FUNC(:($modu.$meth), libnm)
 end
+
+for (meth, libnm, modu) in [
+    (:gamma,:gamma,:SpecialFunctions),
+    (:loggamma,:loggamma,:SpecialFunctions),
+    (:eta,:dirichlet_eta,:SpecialFunctions),
+    (:zeta,:zeta,:SpecialFunctions),
+    (:erf, :erf, :SpecialFunctions),
+    (:erfc, :erfc, :SpecialFunctions)
+]
+    eval(:(import $modu.$meth))
+    IMPLEMENT_ONE_ARG_FUNC(:($modu.$meth), libnm)
+end
+
+for (meth, libnm, modu) in [
+    (:beta, :beta, :SpecialFunctions),
+    (:polygamma, :polygamma, :SpecialFunctions),
+    (:loggamma,:loggamma,:SpecialFunctions),
+    ]
+    eval(:(import $modu.$meth))
+    IMPLEMENT_TWO_ARG_FUNC(:($modu.$meth), libnm)
+end
+
 Base.abs2(x::SymEngine.Basic) = abs(x)^2
 
+
+
 if get_symbol(:basic_atan2) != C_NULL
     import Base.atan
     IMPLEMENT_TWO_ARG_FUNC(:(Base.atan), :atan2)

src/numerics.jl

@@ -262,12 +262,6 @@ end
 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)))
-ceil(::Type{T},x::Basic) where {T <: Integer} = convert(T, ceil(x))
-
-floor(x::Basic) = Basic(floor(N(x)))
-floor(::Type{T},x::Basic) where {T <: Integer} = convert(T, floor(x))
-
 round(x::Basic; kwargs...) = Basic(round(N(x); kwargs...))
 round(::Type{T},x::Basic; kwargs...) where {T <: Integer} = convert(T, round(x; kwargs...))