Merge pull request #425 from JuliaSymbolics/s/safe-real

SafeReal

Author: shashi

src/methods.jl

@@ -19,7 +19,13 @@ const diadic = [max, min, hypot, atan, mod, rem, copysign,
                 polygamma, beta, logbeta]
 const previously_declared_for = Set([])
 
-# TODO: it's not possible to dispatch on the symtype! (only problem is Parameter{})
+#################### SafeReal #########################
+export SafeReal
+
+# ideally the relationship should be the other way around
+abstract type SafeReal <: Real end
+
+#######################################################
 
 assert_like(f, T) = nothing
 function assert_like(f, T, a, b...)
@@ -82,23 +88,36 @@ end
 @number_methods(Pow, term(f, a), term(f, a, b), skipbasics)
 @number_methods(Div, term(f, a), term(f, a, b), skipbasics)
 
-for f in diadic
-    @eval promote_symtype(::$(typeof(f)),
-                   T::Type{<:Number},
-                   S::Type{<:Number}) = promote_type(T, S)
-end
-
-for f in [+, -, *, \, /, ^]
+for f in vcat(diadic, [+, -, *, \, /, ^])
     @eval promote_symtype(::$(typeof(f)),
                    T::Type{<:Number},
                    S::Type{<:Number}) = promote_type(T, S)
+    @eval function promote_symtype(::$(typeof(f)),
+                   T::Type{<:SafeReal},
+                   S::Type{<:Real})
+        X = promote_type(T, Real)
+        X == Real ? SafeReal : X
+    end
+    @eval function promote_symtype(::$(typeof(f)),
+                   T::Type{<:Real},
+                   S::Type{<:SafeReal})
+        X = promote_type(Real, S)
+        X == Real ? SafeReal : X
+    end
+    @eval function promote_symtype(::$(typeof(f)),
+                   T::Type{<:SafeReal},
+                   S::Type{<:SafeReal})
+        X = promote_type(Real, Real)
+        X == Real ? SafeReal : X
+    end
 end
 
 promote_symtype(::typeof(rem2pi), T::Type{<:Number}, mode) = T
 Base.rem2pi(x::Symbolic{<:Number}, mode::Base.RoundingMode) = term(rem2pi, x, mode)
 
 for f in monadic
     @eval promote_symtype(::$(typeof(f)), T::Type{<:Number}) = promote_type(T, Real)
+    @eval promote_symtype(::$(typeof(f)), T::Type{<:SafeReal}) = SafeReal
     @eval (::$(typeof(f)))(a::Symbolic{<:Number})   = term($f, a)
 end
 

src/types.jl

@@ -698,6 +698,7 @@ function makeadd(sign, coeff, xs...)
     coeff, d
 end
 
+add_t(a::Number,b::Number) = promote_symtype(+, symtype(a), symtype(b))
 add_t(a,b) = promote_symtype(+, symtype(a), symtype(b))
 sub_t(a,b) = promote_symtype(-, symtype(a), symtype(b))
 sub_t(a) = promote_symtype(-, symtype(a))
@@ -923,6 +924,9 @@ maybe_intcoeff(x::Rational) = isone(x.den) ? x.num : x
 maybe_intcoeff(x) = x
 
 function (::Type{Div{T}})(n, d, simplified=false; metadata=nothing) where {T}
+    if T<:Number && !(T<:SafeReal)
+        n, d = quick_cancel(n, d)
+    end
     _iszero(n) && return zero(typeof(n))
     _isone(d) && return n
 

test/basics.jl

@@ -238,7 +238,7 @@ end
 end
 
 @testset "div" begin
-    @syms x y
+    @syms x::SafeReal y::Real
     @test (2x/2y).num isa Sym
     @test (2x/3y).num.coeff == 2
     @test (2x/3y).den.coeff == 3
@@ -247,4 +247,13 @@ end
     @test (2.5x/3x).num.coeff == 2.5
     @test (2.5x/3x).den.coeff == 3
     @test (x/3x).den.coeff == 3
+
+    @syms x y
+    @test (2x/2y).num isa Sym
+    @test (2x/3y).num.coeff == 2
+    @test (2x/3y).den.coeff == 3
+    @test (2x/-3x) == -2//3
+    @test (2.5x/3x).num == 2.5
+    @test (2.5x/3x).den == 3
+    @test (x/3x) == 1//3
 end