add True, False

src/SymEngine.jl

@@ -36,6 +36,10 @@ include("dense-matrix.jl")
 
 function __init__()
     init_constants()
+
+    global TrueFalseMap = CMapBasicBasic()
+    TrueFalseMap[True] = ONE
+    TrueFalseMap[False] = ZERO
 end
 
 end

src/mathops.jl

@@ -95,7 +95,8 @@ Base.one(::Type{T}) where {T<:BasicType} = BasicType(Basic(1))
 ## Math constants
 ## no oo!
 
-for op in [:IM, :PI, :E, :EulerGamma, :Catalan, :GoldenRatio, :oo, :zoo, :NAN]
+for op in [:IM, :PI, :E, :EulerGamma, :Catalan, :GoldenRatio, :oo, :zoo,
+    :NEGINFINITY, :NAN, :ZERO, :ONE, :MINUSONE, :True, :False]
     @eval begin
         const $op = Basic(C_NULL)
     end
@@ -123,15 +124,22 @@ function init_constants()
     @init_constant GoldenRatio GoldenRatio
     @init_constant oo infinity
     @init_constant zoo complex_infinity
+    @init_constant NEGINFINITY neginfinity
     @init_constant NAN nan
+    @init_constant ZERO zero
+    @init_constant ONE one
+    @init_constant MINUSONE minus_one
+    ccall((:bool_set_true, libsymengine), Nothing, (Ref{Basic},), True)
+    ccall((:bool_set_false, libsymengine), Nothing, (Ref{Basic},), False)
 end
 
-## ## Conversions
+## Conversions
 Base.convert(::Type{Basic}, x::Irrational{:π}) = PI
 Base.convert(::Type{Basic}, x::Irrational{:e}) = E
 Base.convert(::Type{Basic}, x::Irrational{:γ}) = EulerGamma
 Base.convert(::Type{Basic}, x::Irrational{:catalan}) = Catalan
 Base.convert(::Type{Basic}, x::Irrational{:φ}) = (1 + Basic(5)^Basic(1//2))/2
+Base.convert(::Type{Basic}, x::Bool) = x ? True : False
 Base.convert(::Type{BasicType}, x::Irrational) = BasicType(convert(Basic, x))
 
 ## Logical operators

src/numerics.jl

@@ -12,6 +12,8 @@ function evalf(b::Basic, bits::Integer=53, real::Bool=false)
     if status == 0
         return c
     else
+        b′ = subs(b, TrueFalseMap) # replace any True/False with 1/0
+        b′ != b && return evalf(b′, bits, real)
         throw(ArgumentError("symbolic value cannot be evaluated to a numeric value"))
     end
 end
@@ -91,6 +93,7 @@ N(::Val{:RealMPFR},   b::Basic) = _convert(BigFloat, b)
 N(::Val{:Complex},    b::Basic) = complex(N(real(b)), N(imag(b)))
 N(::Val{:ComplexMPC}, b::Basic) = complex(N(real(b)), N(imag(b)))
 N(::Val{:ComplexDouble}, b::Basic) = complex(N(real(b)), N(imag(b)))
+N(::Val{:BooleanAtom}, b::Basic) = b == True ? 1 : 0
 
 N(::Val{:NaN},        b::Basic) = NaN
 function N(::Val{:Infty}, b::Basic)

src/subs.jl

@@ -80,7 +80,7 @@ function _convert(::Type{Expr}, ex::Basic)
 
     if fn == :Symbol
         return nameof(ex)
-    elseif (fn in number_types) || (fn == :Constant)
+    elseif (fn in number_types) || (fn == :Constant) || (fn == :BooleanAtom)
         return N(ex)
     end
 

src/types.jl

@@ -82,6 +82,7 @@ Basic(x::Basic) = x
 Base.promote_rule(::Type{Basic}, ::Type{S}) where {S<:Number} = Basic
 Base.promote_rule(::Type{S}, ::Type{Basic}) where {S<:Number} = Basic
 Base.promote_rule(::Type{S}, ::Type{Basic}) where {S<:AbstractIrrational} = Basic
+Base.promote_rule(::Type{Bool}, ::Type{Basic}) = Basic
 
 ## Class ID
 get_type(s::Basic) = ccall((:basic_get_type, libsymengine), UInt, (Ref{Basic},), s)

src/utils.jl

@@ -33,4 +33,3 @@ function have_component(comp::String)
         false
     end
 end
-

test/runtests.jl

@@ -386,6 +386,13 @@ expr = x^3 + 3*x^2*y + 3*x*y^2 + y^3 + 1
     end
 end
 
+@testset "Symbolic Booleans" begin
+    @test N(True) == 1
+    @test N(False) == 0
+    v = Basic(1) + True
+    @test N(v) == 1 + true
+end
+
 @test round(Basic(3.14)) == 3.0
 @test round(Basic(3.14); digits=1) == 3.1