Merge pull request #262 from Suavesito-Olimpiada/suave/conj_rule

Simplify `conj` and `real` for `::Real`

Author: shashi

src/methods.jl

@@ -4,12 +4,12 @@ import SpecialFunctions: gamma, loggamma, erf, erfc, erfcinv, erfi, erfcx,
                          besselj1, bessely0, bessely1, besselj, bessely, besseli,
                          besselk, hankelh1, hankelh2, polygamma, beta, logbeta
 
-const monadic = [deg2rad, rad2deg, transpose, conj, asind, log1p, acsch,
+const monadic = [deg2rad, rad2deg, transpose, asind, log1p, acsch,
                  acos, asec, acosh, acsc, cscd, log, tand, log10, csch, asinh,
                  abs2, cosh, sin, cos, atan, cospi, cbrt, acosd, acoth, acotd,
                  asecd, exp, acot, sqrt, sind, sinpi, asech, log2, tan, exp10,
                  sech, coth, asin, cotd, cosd, sinh, abs, csc, tanh, secd,
-                 atand, sec, acscd, cot, exp2, expm1, atanh, real, gamma,
+                 atand, sec, acscd, cot, exp2, expm1, atanh, gamma,
                  loggamma, erf, erfc, erfcinv, erfi, erfcx, dawson, digamma,
                  trigamma, invdigamma, polygamma, airyai, airyaiprime, airybi,
                  airybiprime, besselj0, besselj1, bessely0, bessely1]
@@ -97,9 +97,6 @@ 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
-    if f in [real]
-        continue
-    end
     @eval promote_symtype(::$(typeof(f)), T::Type{<:Number}) = promote_type(T, Real)
     @eval (::$(typeof(f)))(a::Symbolic{<:Number})   = term($f, a)
 end
@@ -113,6 +110,10 @@ end
 
 promote_symtype(::typeof(Base.real), T::Type{<:Number}) = Real
 Base.real(s::Symbolic{<:Number}) = islike(s, Real) ? s : term(real, s)
+promote_symtype(::typeof(Base.conj), T::Type{<:Number}) = T
+Base.conj(s::Symbolic{<:Number}) = islike(s, Real) ? s : term(conj, s)
+promote_symtype(::typeof(Base.imag), T::Type{<:Number}) = Real
+Base.imag(s::Symbolic{<:Number}) = islike(s, Real) ? zero(symtype(s)) : term(conj, s)
 
 ## Booleans
 

src/simplify_rules.jl

@@ -51,6 +51,9 @@ let
         @rule(~x / ~y => ~x * pow(~y, -1))
         @rule(one(~x) => one(symtype(~x)))
         @rule(zero(~x) => zero(symtype(~x)))
+        @rule(conj(~x::_isreal) => ~x)
+        @rule(real(~x::_isreal) => ~x)
+        @rule(imag(~x::_isreal) => zero(symtype(~x)))
         @rule(ifelse(~x::is_literal_number, ~y, ~z) => ~x ? ~y : ~z)
     ]
 

src/utils.jl

@@ -115,6 +115,7 @@ is_literal_number(x) = isliteral(Number)(x)
 _iszero(x) = x isa Number && iszero(x)
 _isone(x) = x isa Number && isone(x)
 _isinteger(x) = (x isa Number && isinteger(x)) || (x isa Symbolic && symtype(x) <: Integer)
+_isreal(x) = (x isa Number && isreal(x)) || (x isa Symbolic && symtype(x) <: Real)
 
 issortedₑ(args) = issorted(args, lt=<ₑ)
 needs_sorting(f) = x -> is_operation(f)(x) && !issortedₑ(arguments(x))

test/rulesets.jl

@@ -1,5 +1,5 @@
 using Random: shuffle, seed!
-using SymbolicUtils: getdepth, Rewriters
+using SymbolicUtils: getdepth, Rewriters, Term
 
 @testset "Chain, Postwalk and Fixpoint" begin
     @syms w z α::Real β::Real
@@ -18,6 +18,9 @@ end
 
 @testset "Numeric" begin
     @syms a::Integer b c d x::Real y::Number
+    @eqtest simplify(Term{Real}(conj, [x])) == x
+    @eqtest simplify(Term{Real}(real, [x])) == x
+    @eqtest simplify(Term{Real}(imag, [x])) == 0
     @eqtest simplify(x - y) == x + -1*y
     @eqtest simplify(x - sin(y)) == x + -1*sin(y)
     @eqtest simplify(-sin(x)) == -1*sin(x)